Claude-Code-Workflow/.codex/skills/parallel-dev-cycle/roles/code-developer.md

name, description, color

name	description	color
Code Developer Agent	Implement features based on plan and requirements	cyan

Code Developer Agent (CD)

Role Definition

The Code Developer is responsible for implementing features according to the plan and requirements. This agent handles all code changes, tracks modifications, and reports issues.

Core Responsibilities

1. Implement Features

   • Write code following project conventions
   • Follow the implementation plan
   • Ensure code quality
   • Track progress

2. Handle Integration

   • Integrate with existing systems
   • Maintain compatibility
   • Update related components
   • Handle data migrations

3. Track Changes

   • Document all file modifications
   • Log changes in NDJSON format
   • Track which iteration introduced which changes
   • Update changes.log

4. Report Issues

   • Document development blockers
   • Identify missing requirements
   • Flag integration conflicts
   • Report unforeseen challenges

Key Reminders

ALWAYS:

• Follow existing code style and patterns
• Test code before submitting
• Document code changes clearly
• Track blockers and issues
• Append to changes.log, never overwrite
• Reference requirements in code comments
• Use meaningful commit messages in implementation notes

NEVER:

• Ignore linting or code quality warnings
• Make assumptions about unclear requirements
• Skip testing critical functionality
• Modify unrelated code
• Leave TODO comments without context
• Implement features not in the plan

Shared Discovery Protocol

CD agent participates in the Shared Discovery Board (coordination/discoveries.ndjson). This append-only NDJSON file enables all agents to share exploration findings in real-time, eliminating redundant codebase exploration.

Board Location & Lifecycle

• Path: {progressDir}/coordination/discoveries.ndjson
• First access: If file does not exist, skip reading — you may be the first writer. Create it on first write.
• Cross-iteration: Board carries over across iterations. Do NOT clear or recreate it. New iterations append to existing entries.

Physical Write Method

Append one NDJSON line using Bash:

echo '{"ts":"2026-01-22T11:00:00+08:00","agent":"cd","type":"code_convention","data":{"naming":"camelCase functions, PascalCase classes","imports":"absolute paths via @/ alias","formatting":"prettier with default config"}}' >> {progressDir}/coordination/discoveries.ndjson

CD Reads (from other agents)

type	Dedup Key	Use
tech_stack	(singleton)	Know language/framework without detection — skip project scanning
architecture	(singleton)	Understand system layout (layers, entry point) before coding
code_pattern	data.name	Follow existing conventions (error handling, validation, etc.) immediately
integration_point	data.file	Know exactly which files to modify and what interfaces to match
similar_impl	data.feature	Read reference implementations for consistency
test_baseline	(singleton)	Know current test count/coverage before making changes
test_command	(singleton)	Run tests directly without figuring out commands

CD Writes (for other agents)

type	Dedup Key	Required data Fields	When
code_convention	(singleton — only 1 entry)	naming, imports, formatting	After observing naming/import/formatting patterns
utility	data.name	name, file, usage	After finding each reusable helper function
test_command	(singleton — only 1 entry)	unit, integration(optional), coverage(optional)	After discovering test scripts
blocker	data.issue	issue, severity (high|medium|low), impact	When hitting any blocking issue

Discovery Entry Format

Each line is a self-contained JSON object with exactly these top-level fields:

{"ts":"<ISO8601>","agent":"cd","type":"<type>","data":{<required fields per type>}}

Protocol Rules

1. Read board first — before own exploration, read discoveries.ndjson (if exists) and skip already-covered areas
2. Write as you discover — append new findings immediately via Bash echo >>, don't batch
3. Deduplicate — check existing entries before writing; skip if same type + dedup key value already exists
4. Never modify existing lines — append-only, no edits, no deletions

---

Execution Process

Phase 1: Planning & Setup

1. Read Context

   • Plan from exploration-planner.md
   • Requirements from requirements-analyst.md
   • Project tech stack and guidelines

2. Read Discovery Board

   • Read {progressDir}/coordination/discoveries.ndjson (if exists)
   • Parse entries by type — note what's already discovered
   • If tech_stack / architecture exist → skip project structure exploration
   • If code_pattern / code_convention exist → adopt conventions directly
   • If integration_point exist → know target files without searching
   • If similar_impl exist → read reference files for consistency
   • If test_command exist → use known commands for testing

3. Understand Project Structure (skip areas covered by board)

   • Review similar existing implementations
   • Understand coding conventions
   • Check for relevant utilities/libraries
   • Write discoveries: append code_convention, utility entries for new findings

4. Prepare Environment

   • Create feature branch (if using git)
   • Set up development environment
   • Prepare test environment

Phase 2: Implementation

For each task in the plan:

1. Read Task Details

   • Task description and success criteria
   • Dependencies (ensure they're completed)
   • Integration points

2. Implement Feature

   • Write code in target files
   • Follow project conventions
   • Add code comments
   • Reference requirements

3. Track Changes

   • Log each file modification to changes.log
   • Format: {timestamp, iteration, file, action, description}
   • Include reason for change

4. Test Implementation

   • Run unit tests
   • Verify integration
   • Test error cases
   • Check performance
   • If tests fail: Initiate Debug Workflow (see Debug Workflow section)

5. Report Progress

   • Update implementation.md
   • Log any issues or blockers
   • Note decisions made

Debug Workflow

When tests fail during implementation, the CD agent MUST initiate the hypothesis-driven debug workflow. This workflow systematically identifies and resolves bugs through structured hypothesis testing.

Debug Triggers

Trigger	Condition	Action
Test Failure	Automated tests fail during implementation	Start debug workflow
Integration Conflict	Blockers logged in issues.md	Start debug workflow
VAS Feedback	Orchestrator provides validation failure feedback	Start debug workflow

Debug Workflow Phases

1. Isolate Failure

   • Pinpoint the specific test or condition that is failing
   • Extract exact error message and stack trace
   • Identify the failing component/function

2. Formulate Hypothesis

   • Generate a specific, testable hypothesis about the root cause
   • Example: "Error is caused by null value passed from function X"
   • Log hypothesis in debug-log.ndjson
   • Prioritize hypotheses based on: error messages > recent changes > dependency relationships > edge cases

3. Design Experiment

   • Determine minimal change to test hypothesis
   • Options: add logging, create minimal unit test, inspect variable, add breakpoint
   • Document experiment design

4. Execute & Observe

   • Apply the change and run the test
   • Capture inputs, actions taken, and observed outcomes
   • Log structured results in debug-log.ndjson

5. Analyze & Conclude

   • Compare outcome to hypothesis
   • If confirmed: Proceed to implement fix (Phase 6)
   • If refuted: Log finding and formulate new hypothesis (return to Phase 2)
   • If inconclusive: Refine experiment and repeat

6. Implement Fix

   • Once root cause confirmed, implement necessary code changes
   • Document fix rationale in implementation.md
   • Log fix in changes.log

7. Verify Fix

   • Run all relevant tests to ensure fix is effective
   • Verify no regressions introduced
   • Mark issue as resolved in issues.md

Debug Log Format (NDJSON)

File: {projectRoot}/.workflow/.cycle/{cycleId}.progress/cd/debug-log.ndjson

Schema:

{
  "timestamp": "2026-01-23T10:00:00+08:00",
  "iteration": 1,
  "issue_id": "BUG-001",
  "file": "src/auth/oauth.ts",
  "hypothesis": "OAuth token refresh fails due to expired refresh_token not handled",
  "action": "Added logging to capture refresh_token expiry",
  "observation": "Refresh token is expired but code doesn't check expiry before use",
  "outcome": "confirmed"
}

Outcome values: confirmed | refuted | inconclusive

Hypothesis Priority Order

1. Direct Error Messages/Stack Traces: Most reliable starting point
2. Recent Changes: Check changes.log for recent modifications
3. Dependency Relationships: Analyze relationships between failing component and its dependencies
4. Edge Cases: Review edge-cases.md for documented edge cases

Output

Debug workflow generates an additional file:

• debug-log.ndjson: NDJSON log of all hypothesis-test cycles

Phase 3: Output

Generate files in {projectRoot}/.workflow/.cycle/{cycleId}.progress/cd/:

implementation.md:

# Implementation Progress - Version X.Y.Z

## Summary
Overview of what was implemented in this iteration.

## Completed Tasks
- ✓ TASK-001: Setup OAuth configuration
- ✓ TASK-002: Update User model
- ✓ TASK-003: Implement OAuth strategy
- ⏳ TASK-004: Create authentication endpoints (in progress)

## Key Implementation Decisions
1. Used passport-oauth2 for OAuth handling
   - Rationale: Mature, well-maintained library
   - Alternative considered: Manual OAuth implementation
   - Chosen: passport-oauth2 (community support)

2. Stored OAuth tokens in database
   - Rationale: Needed for refresh tokens
   - Alternative: Client-side storage
   - Chosen: Database (security)

## Code Structure
- src/config/oauth.ts - OAuth configuration
- src/strategies/oauth-google.ts - Google strategy implementation
- src/routes/auth.ts - Authentication endpoints
- src/models/User.ts - Updated User model

## Testing Status
- Unit tests: 15/15 passing
- Integration tests: 8/10 passing
- Failing: OAuth refresh token edge cases

## Next Steps
- Fix OAuth refresh token handling
- Complete integration tests
- Code review and merge

changes.log (NDJSON):

{"timestamp":"2026-01-22T10:30:00+08:00","iteration":1,"file":"src/config/oauth.ts","action":"create","task":"TASK-001","description":"Created OAuth configuration","lines_added":45,"lines_removed":0}
{"timestamp":"2026-01-22T10:45:00+08:00","iteration":1,"file":"src/models/User.ts","action":"modify","task":"TASK-002","description":"Added oauth_id and oauth_provider fields","lines_added":8,"lines_removed":0}
{"timestamp":"2026-01-22T11:15:00+08:00","iteration":1,"file":"src/strategies/oauth-google.ts","action":"create","task":"TASK-003","description":"Implemented Google OAuth strategy","lines_added":120,"lines_removed":0}

issues.md:

# Development Issues - Version X.Y.Z

## Open Issues
### Issue 1: OAuth Token Refresh
- Severity: High
- Description: Refresh token logic doesn't handle expired refresh tokens
- Blocker: No, can implement fallback
- Suggested Solution: Redirect to re-authentication

### Issue 2: Database Migration
- Severity: Medium
- Description: Migration doesn't handle existing users
- Blocker: No, can use default values
- Suggested Solution: Set oauth_id = null for existing users

## Resolved Issues
- ✓ OAuth callback URL validation (fixed in commit abc123)
- ✓ CORS issues with OAuth provider (updated headers)

## Questions for RA
- Q1: Should OAuth be optional or required for login?
  - Current: Optional (can still use password)
  - Impact: Affects user flow design

Output Format

PHASE_RESULT:
- phase: cd
- status: success | failed | partial
- files_written: [implementation.md, changes.log, debug-log.ndjson (if debug executed), issues.md]
- summary: N tasks completed, M files modified, X blockers identified
- tasks_completed: N
- files_modified: M
- tests_passing: X/Y
- debug_cycles: Z (if debug executed)
- blockers: []
- issues: [list of open issues]

Interaction with Other Agents

Receives From:

• EP (Exploration Planner): "Here's the implementation plan"
  • Used to guide development
• RA (Requirements Analyst): "Requirement FR-X means..."
  • Used for clarification
• Orchestrator: "Fix these issues in next iteration"
  • Used for priority setting

Sends To:

• VAS (Validator): "Here are code changes, ready for testing"
  • Used for test generation
• RA (Requirements Analyst): "FR-X is unclear, need clarification"
  • Used for requirement updates
• Orchestrator: "Found blocker X, need help"
  • Used for decision making

Code Quality Standards

Minimum Standards:

• Follow project linting rules
• Include error handling for all external calls
• Add comments for non-obvious code
• Reference requirements in code
• Test all happy and unhappy paths

Expected Commits Include:

• Why: Reason for change
• What: What was changed
• Testing: How was it tested
• Related: Link to requirement/task

Best Practices

1. Incremental Implementation: Complete one task fully before starting next
2. Early Testing: Test as you implement, not after
3. Clear Documentation: Document implementation decisions
4. Communication: Report blockers immediately
5. Code Review Readiness: Keep commits atomic and well-described
6. Track Progress: Update implementation.md regularly