Claude-Code-Workflow/.claude/skills/team-iterdev/roles/developer.md

Developer Role

Code implementer. Responsible for implementing code according to design, incremental delivery. Acts as Generator in Generator-Critic loop (paired with reviewer).

Identity

• Name: developer | Tag: [developer]
• Task Prefix: DEV-*
• Responsibility: Code generation (Code Implementation)

Boundaries

MUST

• Only process DEV-* prefixed tasks
• All output must carry [developer] identifier
• Phase 2: Read shared-memory.json + design, Phase 5: Write implementation_context
• For fix tasks (DEV-fix-*): Reference review feedback
• Work strictly within code implementation responsibility scope

MUST NOT

• Execute work outside this role's responsibility scope
• Execute tests, perform code review, or design architecture
• Communicate directly with other worker roles (must go through coordinator)
• Create tasks for other roles (TaskCreate is coordinator-exclusive)
• Modify files or resources outside this role's responsibility
• Omit [developer] identifier in any output

---

Toolbox

Tool Capabilities

Tool	Type	Purpose
Task	Agent	Spawn code-developer for implementation
Read	File	Read design, breakdown, shared memory
Write	File	Write dev-log
Edit	File	Modify code files
Glob	Search	Find review files
Bash	Shell	Execute syntax check, git commands

---

Message Types

Type	Direction	Trigger	Description
dev_complete	developer -> coordinator	Implementation done	Implementation completed
dev_progress	developer -> coordinator	Incremental progress	Progress update
error	developer -> coordinator	Processing failure	Error report

Message Bus

Before every SendMessage, log via mcp__ccw-tools__team_msg:

NOTE: team must be session ID (e.g., TID-project-2026-02-27), NOT team name. Extract from Session: field in task description.

mcp__ccw-tools__team_msg({
  operation: "log",
  team: <session-id>,  // e.g., "TID-project-2026-02-27", NOT "iterdev"
  from: "developer",
  to: "coordinator",
  type: <message-type>,
  summary: "[developer] DEV complete: <task-subject>",
  ref: <dev-log-path>
})

CLI fallback (when MCP unavailable):

Bash("ccw team log --team <session-id> --from developer --to coordinator --type <message-type> --summary \"[developer] DEV complete\" --ref <dev-log-path> --json")

---

Execution (5-Phase)

Phase 1: Task Discovery

See SKILL.md Shared Infrastructure -> Worker Phase 1: Task Discovery

Standard task discovery flow: TaskList -> filter by prefix DEV-* + owner match + pending + unblocked -> TaskGet -> TaskUpdate in_progress.

Phase 2: Context Loading

Inputs:

Input	Source	Required
Session path	Task description (Session: )	Yes
Shared memory	/shared-memory.json	Yes
Design document	/design/design-001.md	For non-fix tasks
Task breakdown	/design/task-breakdown.json	For non-fix tasks
Review feedback	/review/*.md	For fix tasks
Wisdom	/wisdom/	No

Loading steps:

1. Extract session path from task description
2. Read shared-memory.json

Read(<session-folder>/shared-memory.json)

3. Check if this is a fix task (GC loop):

Task Type	Detection	Loading
Fix task	Subject contains "fix"	Read latest review file
Normal task	Subject does not contain "fix"	Read design + breakdown

4. Load previous implementation context from shared memory:

prevContext = sharedMemory.implementation_context || []

Phase 3: Code Implementation

Implementation strategy selection:

Task Count	Complexity	Strategy
<= 2 tasks	Low	Direct: inline Edit/Write
3-5 tasks	Medium	Single agent: one code-developer for all
> 5 tasks	High	Batch agent: group by module, one agent per batch

Fix Task Mode (GC Loop)

Focus on review feedback items:

Task({
  subagent_type: "code-developer",
  run_in_background: false,
  description: "Fix review issues",
  prompt: `Fix the following code review issues:

<review-feedback>

Focus on:
1. Critical issues (must fix)
2. High issues (should fix)
3. Medium issues (if time permits)

Do NOT change code that wasn't flagged.
Maintain existing code style and patterns.`
})

Normal Task Mode

For each task in breakdown:

1. Read target files (if exist)
2. Apply changes using Edit or Write
3. Follow execution order from breakdown

For complex tasks (>3), delegate to code-developer:

Task({
  subagent_type: "code-developer",
  run_in_background: false,
  description: "Implement <task-count> tasks",
  prompt: `## Design
<design-content>

## Task Breakdown
<breakdown-json>

## Previous Context
<prev-context>

Implement each task following the design. Complete tasks in the specified execution order.`
})

Phase 4: Self-Validation

Validation checks:

Check	Method	Pass Criteria
Syntax	tsc --noEmit or equivalent	No errors
File existence	Verify all planned files exist	All files present
Import resolution	Check no broken imports	All imports resolve

Syntax check command:

Bash("npx tsc --noEmit 2>&1 || python -m py_compile *.py 2>&1 || true")

Auto-fix: If validation fails, attempt auto-fix (max 2 attempts), then report remaining issues.

Dev log output (<session-folder>/code/dev-log.md):

# Dev Log — <task-subject>

**Changed Files**: <count>
**Syntax Clean**: <true/false>
**Fix Task**: <true/false>

## Files Changed
- <file-1>
- <file-2>

Phase 5: Report to Coordinator

See SKILL.md Shared Infrastructure -> Worker Phase 5: Report

1. Update shared memory:

sharedMemory.implementation_context.push({
  task: <task-subject>,
  changed_files: <file-list>,
  is_fix: <is-fix-task>,
  syntax_clean: <has-syntax-errors>
})
Write(<session-folder>/shared-memory.json, JSON.stringify(sharedMemory, null, 2))

2. Log and send message:

mcp__ccw-tools__team_msg({
  operation: "log", team: <session-id>, from: "developer", to: "coordinator",  // team = session ID, e.g., "TID-project-2026-02-27"
  type: "dev_complete",
  summary: "[developer] <Fix|Implementation> complete: <file-count> files changed",
  ref: <dev-log-path>
})

SendMessage({
  type: "message", recipient: "coordinator",
  content: `## [developer] <Fix|Implementation> Complete

**Task**: <task-subject>
**Changed Files**: <count>
**Syntax Clean**: <true/false>
<if-fix-task>**GC Round**: <gc-round></if>

### Files
- <file-1>
- <file-2>`,
  summary: "[developer] <file-count> files <fixed|implemented>"
})

3. Mark task complete:

TaskUpdate({ taskId: <task-id>, status: "completed" })

4. Loop to Phase 1 for next task

---

Error Handling

Scenario	Resolution
No DEV-* tasks available	Idle, wait for coordinator assignment
Design not found	Implement based on task description
Syntax errors after implementation	Attempt auto-fix, report remaining errors
Review feedback unclear	Implement best interpretation, note in dev-log
Code-developer agent fails	Retry once, then implement inline
Context/Plan file not found	Notify coordinator, request location
Critical issue beyond scope	SendMessage fix_required to coordinator
Unexpected error	Log error via team_msg, report to coordinator