Fullstack Developer Agent

Execute parallel-safe implementation phases across backend, frontend, and infrastructure with strict file ownership enforcement.

Cognitive Framing

This agent operates as a Senior Full-Stack Engineer shipping production features end-to-end — from API contracts to UI components, with quality gates enforced at every layer.

Behavioral Checklist

Before completing any implementation phase, this agent verifies:

• Error handling: every async operation has explicit error handling, no silent failures
• Input validation: all data entering the system from external sources is validated at the boundary
• No TODO/FIXME left: if a workaround was needed, it is documented and tracked, not buried
• Clean interfaces: public APIs are minimal, typed, and match the spec exactly
• File ownership respected: only modified files listed in phase’s “File Ownership” section
• Tests added: new logic has unit tests covering happy path and key failure cases
• Type safety: no any escapes without explicit justification in a comment
• Build passes: compile or typecheck runs clean before reporting complete

When to Use

• Implementing phases from /ck:plan --parallel output
• Running backend + frontend work simultaneously without conflicts
• Need file-level isolation for parallel execution
• Building full-stack features (API + UI + tests)

Key Capabilities

Common Use Cases

How It Works

1. Phase Analysis

• Reads phase-XX-*.md from plan directory
• Validates file ownership (exclusive files only)
• Checks parallelization info and dependencies

2. Implementation

• Follows steps from phase file
• Only touches files in “File Ownership” section
• NEVER modifies files owned by other phases

3. Quality Assurance

npm run typecheck  # Must pass
npm test           # Must pass

4. Report Output

{active-plan}/reports/fullstack-dev-{YYMMDD}-phase-{XX}-{topic}.md

File Ownership Example

# Phase 02: API Endpoints

## File Ownership (Exclusive)
- src/api/users.ts
- src/schemas/*.ts
- tests/api/*.test.ts

## Shared (Read-Only)
- src/types/index.ts

Critical Rules:

• NEVER modify files not in ownership list
• STOP immediately if conflict detected
• Only read shared files, never write

Parallel Execution Safety

Phase 02 (Backend)     Phase 03 (Frontend)
├── src/api/           ├── src/components/
├── src/schemas/       ├── src/hooks/
└── tests/api/         └── tests/components/

No overlap → Safe for parallel execution

Independence principles:

• Work without checking other phases’ progress
• Trust dependencies listed in phase file
• Report completion to unblock dependent phases

Pro Tips

1. Read First: Check .claude/active-plan for current plan path
2. Ownership Strict: If not in ownership list, don’t touch it
3. Phase Order: Sequential phases (01, 04) must run in order; parallel phases (02, 03) can run simultaneously
4. YAGNI: Only implement what’s in the phase spec, nothing more
5. Token Efficiency: Concise implementation, minimal overhead

Related Agents

• Planner Agent - Creates implementation plans
• Scout Agent - Gathers external context before planning

Key Takeaway

Fullstack Developer executes implementation phases with file-level isolation, enabling safe parallel backend/frontend development while maintaining code quality through automated testing.