Imported from majiayu000/claude-skill-registry-data (data/dev-swarm-code-development/SKILL.md). Install upstream with npx skills add majiayu000/claude-skill-registry-data --skill dev-swarm-code-development. Copyright stays with the author.

AI Builder - Code Development

This skill implements backlogs through a structured feature-driven approach. As a Software Engineer expert, you'll read backlog requirements, reference existing features, design implementation approach, write code, and create comprehensive documentation for the features knowledge base.

When to Use This Skill

• User asks to implement a backlog
• User requests to complete a feature, change, bug fix, or improvement
• User says "develop backlog X"
• User wants to implement work from sprint
• User asks to code a specific backlog item

Prerequisites

This skill requires:

• 04-prd/ - Product Requirements Document (business requirements and acceptance criteria)
• 07-tech-specs/ - Engineering standards and constraints
• 09-sprints/ folder with active sprint and backlogs
• features/ folder with features-index.md (existing features knowledge base)
• Understanding of the backlog type: FEATURE, CHANGE, BUG, or IMPROVE

Feature-Driven Development Workflow

CRITICAL: This skill follows a strict feature-driven approach where feature-name is the index for the entire project:

For Each Backlog:

1. Read backlog from 09-sprints/SPRINT-XX-descriptive-name/[BACKLOG_TYPE]-XX-[feature-name]-<sub-feature>.md
2. Extract the feature-name from the backlog file name
3. Read features/features-index.md to find the feature file
4. Read feature documentation in this order:
   • features/[feature-name].md - Feature definition (WHAT/WHY/SCOPE)
   • features/flows/[feature-name].md - User flows and process flows (if exists)
   • features/contracts/[feature-name].md - API/data contracts (if exists)
   • features/impl/[feature-name].md - Implementation notes (if exists)
5. Locate source code at src/ using features/impl/[feature-name].md
6. Implement the code following 07-tech-specs/
7. Update backlog with development notes

This approach ensures AI developers can work on large projects without reading all code at once.

Your Roles in This Skill

See dev-swarm/docs/general-dev-stage-rule.md for role selection guidance.

Role Communication

See dev-swarm/docs/general-dev-stage-rule.md for the required role announcement format.

Instructions

Follow these steps in order for coding development:

Step 0: Verify Prerequisites and Gather Context

IMPORTANT: Follow this exact order to efficiently locate all relevant context:

1. Identify the backlog:

   • User specifies which backlog to work on
   • Or you select next backlog from 09-sprints/ in order

   09-sprints/
   └── SPRINT-XX-descriptive-name/
       └── [BACKLOG_TYPE]-XX-[feature-name]-<sub-feature>.md
   

   • Locate the sprint README at 09-sprints/SPRINT-XX-descriptive-name/README.md for required progress log updates

2. Read the backlog file:

   • Understand task description and requirements
   • Note backlog type (FEATURE/CHANGE/BUG/IMPROVE)
   • Extract the feature-name from the file name (CRITICAL)
   • Verify Feature Name in backlog metadata matches the file name
   • If they do not match, stop and ask the user to confirm the correct feature name
   • Review test plan requirements
   • Identify acceptance criteria

3. Read source code structure standards:

   • Read dev-swarm/docs/source-code-structure.md for general guidelines
   • Note file naming conventions and directory structure

4. Read PRD and tech specs:

   • Read 04-prd/ (all markdown files) - Product requirements and acceptance criteria for the feature
   • Read 07-tech-specs/ (all markdown files) - Technical specifications and engineering standards
   • Understand the business context and technical constraints

5. Read feature documentation (using feature-name as index):

   • Read features/features-index.md to confirm feature exists
   • Read features/[feature-name].md - Feature definition (WHAT/WHY/SCOPE)
   • Read features/flows/[feature-name].md - User flows (if exists)
   • Read features/contracts/[feature-name].md - API contracts (if exists)
   • Read features/impl/[feature-name].md - Implementation notes (if exists)

6. Locate existing source code:

   • Use features/impl/[feature-name].md to find code locations
   • Navigate to src/ directory
   • Review existing code structure and patterns
   • Identify files to modify (CHANGE/BUG/IMPROVE) or create (FEATURE)

7. Understand codebase patterns:

   • Review existing code in src/ using locations from features/impl/[feature-name].md
   • Note architectural patterns and integration points

DO NOT read the entire codebase. Use features/impl/[feature-name].md to find only relevant files in src/.

Step 1: Design the Implementation

Before writing code, create the feature design document:

1. Create/Update file features/{feature-name}.md

   • If backlog type is feature and the related feature file is not exist, create new feature file
   • If backlog type is change/bug/improve or the feature file is exist, update existing feature file
   • Use the provided templates for consistency

2. Create/update flow and contract files if it is needed

   • features/flows/{feature-name}.md - User flows and process flows (when needed)
   • features/contracts/{feature-name}.md - API contracts and interfaces (when needed)

3. Present design to user for approval

   • Show the feature design document
   • Explain approach and rationale
   • Highlight any assumptions or decisions
   • Wait for user confirmation before proceeding

Step 2: Implement the Code (After User Confirms)

Once user approves the design:

1. Organize code in src/:

   • Follow dev-swarm/docs/source-code-structure.md for file organization guidelines
   • Place code in appropriate locations within src/
   • Use file naming conventions defined in source-code-structure.md

2. Write the code:

   • Implement according to the approved design
   • Follow coding standards
   • Write clean, modular, maintainable code
   • Include appropriate error handling
   • Avoid over-engineering (keep it simple)

3. Code quality guidelines:

   • Modular: Break code into small, focused functions/components
   • Readable: Clear variable names, self-documenting code
   • Simple: Don't add features not in requirements
   • Consistent: Match style of existing codebase
   • Secure: No XSS, SQL injection, command injection, or OWASP vulnerabilities
   • Tested: Code should be testable per backlog test plan

4. What NOT to do:

   • Don't add extra features beyond requirements
   • Don't over-abstract or create unnecessary helpers
   • Don't add comments to code you didn't change
   • Don't refactor code outside scope of backlog
   • Don't add hypothetical error handling
   • Don't create backwards-compatibility hacks

5. For different backlog types:

   Feature (new functionality):

   • Create new files/components
   • Integrate with existing system
   • Follow established patterns

   Change (modify existing feature):

   • Update existing code
   • Maintain compatibility where needed
   • Update related code if necessary

   Bug (fix defect):

   • Fix the specific issue
   • Avoid changing unrelated code
   • Verify fix matches test plan

   Improve (optimize existing code):

   • Refactor/optimize as specified
   • Maintain same functionality
   • Document performance improvements

Step 3: Create Implementation Documentation

After code is complete, create implementation documentation:

1. Create features/impl/{feature-name}.md

   Files Changed:

   • List all files created or modified
   • For each file, note key changes
   • Use file paths, function names as keywords (NOT line numbers)

   Implementation Details:

   • Describe how the feature was implemented
   • Key functions/components created
   • Integration points with other features
   • Any important implementation decisions

   Code Structure:

   • Directory organization
   • Module/component breakdown
   • Dependencies added

   Key Functions/APIs:

   • List important functions with descriptions
   • Document key API endpoints
   • Note important classes/components

   Reference for Developers:

   • Quick keywords for code search
   • How to find relevant code
   • Common use patterns

2. Update features/{feature-name}.md if needed

   • Add any insights discovered during implementation
   • Note if actual implementation differs from design (explain why)
   • Keep it synchronized with current code

3. Update features/features-index.md if needed

4. Update or create src/README.md (Project Documentation):

   • IMPORTANT: Developers should maintain project documentation in src/README.md, NOT in the root README.md
   • Add or update feature documentation:
     • Feature overview and purpose
     • Installation and setup instructions
     • Usage examples and API documentation
     • Configuration options
     • Troubleshooting tips
   • Keep src/README.md as the primary technical reference for developers
   • Include links to features/ documentation for detailed specs

Step 4: Verify Against Test Plan

Before marking complete:

1. Review backlog test plan:

   • Ensure code meets all test requirements
   • Verify acceptance criteria are met

2. Self-test (if possible):

   • Run the code
   • Test key functionality
   • Verify no obvious errors

3. Document test status:

   • Note if manual testing was done
   • List any test results
   • Flag anything needing QA attention

Step 5: Update Backlog with Development Notes

CRITICAL: Update the backlog.md file to track development progress:

1. Update backlog status:

   • Change status from "Not Started" to "In Code Review"
   • Add a "Development Notes" section if not present

2. Document development findings:

   • Files Created/Modified: List all files changed with brief descriptions
   • Implementation Approach: Summarize how requirements were implemented
   • Key Decisions: Note any important technical decisions made
   • Integration Points: Document how code integrates with other features
   • Known Issues: Flag any potential issues for code review
   • Test Notes: Any preliminary testing done during development

3. Reference documentation created:

   • Link to features/[feature-name].md
   • Link to features/impl/[feature-name].md
   • Link to source code files in src/ (locations documented in features/impl/[feature-name].md)

4. Notify user:

   • Summarize what was implemented
   • Reference documentation created
   • Note any important decisions or tradeoffs
   • Suggest next step: "Ready for code review"

5. Update sprint README (README.md) (CRITICAL):

   • Update backlog status in the sprint backlog table
   • Append a log entry in the sprint progress log for the Development step

These backlog.md and sprint README updates create the audit trail for code review and testing phases.

Expected File Structure

project-root/
├── 09-sprints/
│   └── SPRINT-XX-descriptive-name/
│       └── [BACKLOG_TYPE]-XX-[feature-name]-<sub-feature>.md # Backlog entry point
│
├── features/                                # Features knowledge base
│   ├── features-index.md                   # Index of all features
│   ├── [feature-name].md                   # Feature definition (WHAT/WHY/SCOPE)
│   ├── flows/
│   │   └── [feature-name].md               # User flows (if needed)
│   ├── contracts/
│   │   └── [feature-name].md               # API contracts (if needed)
│   └── impl/
│       └── [feature-name].md               # Implementation notes (code locations)
│
└── src/                                     # Source code
    ├── README.md                            # Project documentation (maintained by developers)
    └── [organized per dev-swarm/docs/source-code-structure.md guidelines]

File Templates

1. features-index.md

# Features Index

- [feature name a](feature-name-a.md)
- [feature name b](feature-name-b.md)

2. feature.md

# Title

## Description

[The overview for this feature's implementation, for approval, codeo review, trouble shooting or further development]

## References
The details of this feature's implementation

* [flow](flows/feature-name.md)
* [contract](contracts/feature-name.md)
* [Implement](impl/feature-name.md)

3. flows/feature-name.md - help to understand the code logic

   • User flow diagrams (mermaid)
   • Process flows and sequence diagrams
   • State transitions
   • Integration flows

4. contracts/feature-name.md - the interface between services, pacakges, workflows

   • REST API used or endpoint definitions
   • Request/response schemas
   • Data models and database schemas
   • Event contracts

5. impl/feature-name.md - help to find the code location in the source code file for codeo review, trouble shooting or further development

   • searchable keywords - function name, class name, even comment text in the file
   • file path
   • Dependencies and integration details
   • Avoid citing line numbers in the code file as any code change will affect the line numbers