implement

User Input

You MUST consider the user input before proceeding (if not empty).

Outline

1. Call the akka_sdd_list_specs MCP tool to find features. Verify that tasks.md exists for the target feature (has_tasks must be true). If tasks.md is missing, instruct the user to run /akka:tasks first. Read the tasks.md content from FEATURE_DIR. Also note which other artifacts are available (AVAILABLE_DOCS).

2. Create or check out the feature branch:

   • Read the spec.md from FEATURE_DIR and find the Feature Branch field (e.g. 001-counter-service)
   • Call akka_git_status to check the current branch
   • If not already on the feature branch, call akka_git_create_branch with the branch name from the spec
   • All implementation work must happen on the feature branch, not on main

3. Check checklists status (if FEATURE_DIR/checklists/ exists):

   • Scan all checklist files in the checklists/ directory

   • For each checklist, count:

     • Total items: All lines matching - [ ] or - [X] or - [x]
     • Completed items: Lines matching - [X] or - [x]
     • Incomplete items: Lines matching - [ ]

   • Create a status table:

     | Checklist | Total | Completed | Incomplete | Status |
     |-----------|-------|-----------|------------|--------|
     | ux.md     | 12    | 12        | 0          | ✓ PASS |
     | test.md   | 8     | 5         | 3          | ✗ FAIL |
     | security.md | 6   | 6         | 0          | ✓ PASS |
     

   • Calculate overall status:

     • PASS: All checklists have 0 incomplete items
     • FAIL: One or more checklists have incomplete items

   • If any checklist is incomplete:

     • Display the table with incomplete item counts
     • STOP and ask: "Some checklists are incomplete. Do you want to proceed with implementation anyway? (yes/no)"
     • Wait for user response before continuing
     • If user says "no" or "wait" or "stop", halt execution
     • If user says "yes" or "proceed" or "continue", proceed to step 3

   • If all checklists are complete:

     • Display the table showing all checklists passed
     • Automatically proceed to step 3

4. Load and analyze the implementation context:

   • REQUIRED: Read tasks.md for the complete task list and execution plan
   • REQUIRED: Read plan.md for tech stack, architecture, and file structure — including the Component Architecture table, which fixes the Akka component for each domain concept
   • IF EXISTS: Read data-model.md for entities and relationships
   • IF EXISTS: Read contracts/ for API specifications and test requirements
   • IF EXISTS: Read research.md for technical decisions and constraints
   • IF EXISTS: Read quickstart.md for integration scenarios

5. Project Setup Verification:

   • REQUIRED: Create/verify ignore files based on actual project setup:

   Detection & Creation Logic:

   • Call akka_git_status to determine if the repository is a git repo (create/verify .gitignore if so)
   • Check if Dockerfile* exists or Docker in plan.md → create/verify .dockerignore
   • Check if .eslintrc* exists → create/verify .eslintignore
   • Check if eslint.config.* exists → ensure the config's ignores entries cover required patterns
   • Check if .prettierrc* exists → create/verify .prettierignore
   • Check if .npmrc or package.json exists → create/verify .npmignore (if publishing)
   • Check if terraform files (*.tf) exist → create/verify .terraformignore
   • Check if .helmignore needed (helm charts present) → create/verify .helmignore

   If ignore file already exists: Verify it contains essential patterns, append missing critical patterns only If ignore file missing: Create with full pattern set for detected technology

   Common Patterns by Technology (from plan.md tech stack):

   • Node.js/JavaScript/TypeScript: node_modules/, dist/, build/, *.log, .env*
   • Python: __pycache__/, *.pyc, .venv/, venv/, dist/, *.egg-info/
   • Java: target/, *.class, *.jar, .gradle/, build/
   • C#/.NET: bin/, obj/, *.user, *.suo, packages/
   • Go: *.exe, *.test, vendor/, *.out
   • Ruby: .bundle/, log/, tmp/, *.gem, vendor/bundle/
   • PHP: vendor/, *.log, *.cache, *.env
   • Rust: target/, debug/, release/, *.rs.bk, *.rlib, *.prof*, .idea/, *.log, .env*
   • Kotlin: build/, out/, .gradle/, .idea/, *.class, *.jar, *.iml, *.log, .env*
   • C++: build/, bin/, obj/, out/, *.o, *.so, *.a, *.exe, *.dll, .idea/, *.log, .env*
   • C: build/, bin/, obj/, out/, *.o, *.a, *.so, *.exe, Makefile, config.log, .idea/, *.log, .env*
   • Swift: .build/, DerivedData/, *.swiftpm/, Packages/
   • R: .Rproj.user/, .Rhistory, .RData, .Ruserdata, *.Rproj, packrat/, renv/
   • Universal: .DS_Store, Thumbs.db, *.tmp, *.swp, .vscode/, .idea/

   Tool-Specific Patterns:

   • Docker: node_modules/, .git/, Dockerfile*, .dockerignore, *.log*, .env*, coverage/
   • ESLint: node_modules/, dist/, build/, coverage/, *.min.js
   • Prettier: node_modules/, dist/, build/, coverage/, package-lock.json, yarn.lock, pnpm-lock.yaml
   • Terraform: .terraform/, *.tfstate*, *.tfvars, .terraform.lock.hcl
   • Kubernetes/k8s: *.secret.yaml, secrets/, .kube/, kubeconfig*, *.key, *.crt

6. Parse tasks.md structure and extract:

   • Task phases: Setup, Tests, Core, Integration, Polish
   • Task dependencies: Sequential vs parallel execution rules
   • Task details: ID, description, file paths, parallel markers [P]
   • Execution flow: Order and dependency requirements

7. Execute implementation following the task plan:

   • Phase-by-phase execution: Complete each phase before moving to the next
   • Respect dependencies: Run sequential tasks in order, parallel tasks [P] can run together
   • Follow TDD approach: Execute test tasks before their corresponding implementation tasks
   • File-based coordination: Tasks affecting the same files must run sequentially
   • Validation checkpoints: Verify each phase completion before proceeding

8. Implementation execution rules:

   • Component fidelity: Implement components as mapped in plan.md's Component Architecture table. If a task needs a component not in the table, consult the "Choosing a component type" section of akka-context/sdk/components/index.html.md, then record the addition (with the rejected alternative) in plan.md before coding
   • Setup first: Initialize project structure, dependencies, configuration
   • Tests before code: If you need to write tests for contracts, entities, and integration scenarios
   • Core development: Implement models, services, CLI commands, endpoints
   • Integration work: Database connections, middleware, logging, external services
   • Polish and validation: Unit tests, performance optimization, documentation

9. Progress tracking and error handling:

   • Report progress after each completed task
   • Halt execution if any non-parallel task fails
   • For parallel tasks [P], continue with successful tasks, report failed ones
   • Provide clear error messages with context for debugging
   • Suggest next steps if implementation cannot proceed
   • IMPORTANT For completed tasks, make sure to mark the task off as [X] in the tasks file.

10. Commit the implementation:

• Call akka_git_add to stage all changes
• Call akka_git_commit with a descriptive message summarizing the implemented feature

11. Ask about merging to main:

• Ask the user: "Would you like to merge the feature branch back to main?"
• If yes: call akka_git_checkout to switch to main, then akka_git_merge with the feature branch name
• If no: stay on the feature branch — the user may want to create a PR or continue iterating

12. Completion validation:

• Verify all required tasks are completed
• Check that implemented features match the original specification
• Validate that tests pass and coverage meets requirements
• Confirm the implementation follows the technical plan
• Report final status with summary of completed work

Note: This command assumes a complete task breakdown exists in tasks.md. If tasks are incomplete or missing, suggest running /akka:tasks first to regenerate the task list.

Done When

• [ ] FEATURE_DIR and tasks.md were resolved via akka_sdd_list_specs with has_tasks == true.
• [ ] The current git branch is the feature branch from spec.md (created via akka_git_create_branch if needed) — no implementation work happened on main.
• [ ] The checklists status table was displayed; if any checklist had incomplete items, the user explicitly approved proceeding.
• [ ] Every applicable ignore file (.gitignore, .dockerignore, .eslintignore/eslint config, .prettierignore, .npmignore, .terraformignore, .helmignore) was created or verified with the correct patterns for the detected tech stack.
• [ ] Tasks were executed phase-by-phase, respecting sequential dependencies and running [P] tasks in parallel where safe.
• [ ] Every completed task in tasks.md was marked [X]; any failed task halted execution (or, for [P] tasks, was reported while continuing successful siblings).
• [ ] All changes were staged via akka_git_add and committed via akka_git_commit with a descriptive message.
• [ ] The user was asked whether to merge the feature branch to main; the answer was acted on (akka_git_checkout + akka_git_merge on yes, stay on feature branch on no).
• [ ] The final report validates that implemented features match the spec, tests pass, and the implementation follows the plan.