implement
Execute the implementation plan by processing and executing all tasks defined in tasks.md
SKILL.mdskills/implement/SKILL.md
GitHubUser Input
You MUST consider the user input before proceeding (if not empty).
Outline
Call the
akka_sdd_list_specsMCP 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:tasksfirst. Read the tasks.md content from FEATURE_DIR. Also note which other artifacts are available (AVAILABLE_DOCS).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_statusto check the current branch - If not already on the feature branch, call
akka_git_create_branchwith the branch name from the spec - All implementation work must happen on the feature branch, not on
main
- Read the spec.md from FEATURE_DIR and find the Feature Branch field (e.g.
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
- [ ]
- Total items: All 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
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
Project Setup Verification:
- REQUIRED: Create/verify ignore files based on actual project setup:
Detection & Creation Logic:
- Call
akka_git_statusto 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
ignoresentries 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
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
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
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
- 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
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.
Commit the implementation:
- Call
akka_git_addto stage all changes - Call
akka_git_commitwith a descriptive message summarizing the implemented feature
- Ask about merging to main:
- Ask the user: "Would you like to merge the feature branch back to main?"
- If yes: call
akka_git_checkoutto switch tomain, thenakka_git_mergewith the feature branch name - If no: stay on the feature branch — the user may want to create a PR or continue iterating
- 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.mdwere resolved viaakka_sdd_list_specswithhas_tasks == true. - The current git branch is the feature branch from spec.md (created via
akka_git_create_branchif needed) — no implementation work happened onmain. - 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.mdwas marked[X]; any failed task halted execution (or, for[P]tasks, was reported while continuing successful siblings). - All changes were staged via
akka_git_addand committed viaakka_git_commitwith 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_mergeon 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.