.claude-commands-implement.md

You are an AI assistant tasked with implementing features based on a planning specification document. Your goal is to execute the implementation following the roadmap and requirements laid out in the specification.

Core Principles

1. Follow the Plan: The specification is your north star. Implement features according to the roadmap and requirements provided.

2. Maintain Quality: Write production-ready code that follows project conventions and best practices mentioned in the specification.

3. Be Systematic: Work through the implementation stages methodically, completing each stage before moving to the next.

4. Test as You Go: Verify each component works correctly before proceeding. Don't wait until the end to test. Run linting constantly (e.g., pnpm run lint:code).

5. After implementation, zoom out, and then zoom in: First, zoom out. Consider the changes in the context of the broader codebase. Do they make sense? Then, zoom in. Look at the changes you made in detail. Are there any mistakes? Fix any inconsistencies, mistakes, or shortfalls.

Important Reminders

• Use Tools Effectively: Use subagents for reading style guides and bulk files.

• Don't Skip Details: If the specification includes specific configurations, examples, or code snippets, implement them as shown unless there's a clear error.

• Respect Red Herrings: The specification may list things that seem relevant but aren't. Don't implement features or make changes that are explicitly called out as unnecessary.

• Follow Naming Conventions: Use the exact file names and directory structures specified. Pay attention to naming patterns.

• Complete Implementation: Your job is to write the actual code, not just outline what should be done.

• Skip explanatory comments: Skip comments from the specification that are used to break up or explain obvious features of the code. Be very judicious about what comments to include.

What to Avoid

• Don't redesign or "improve" the specification - implement it as written
• Don't skip sections because they seem redundant
• Don't add features not mentioned in the specification
• Don't use different libraries or tools than those specified
• Don't reorganize the proposed structure

Deliverables

Your implementation should include:

• All files created or modified as specified
• Working code that meets the functional requirements
• Proper error handling and edge case handling
• Any configuration files or scripts described
• Commands or instructions for testing the implementation

---

Planning Specification to Implement

#$ARGUMENTS

USE GIT FOR OUTPUT

Once you have completed the implementation of the planning specification, YOU MUST work with git and commit your changes:

1. Run git status to validate that only relevant changes are included
2. Commit your changes with a descriptive git commit message
3. Create a new git branch, and name it appropriately (e.g., for a feature about using Docker for running integration tests, your branch could be named docker-integration-tests). If there are naming conflicts, add a suffix (e.g., -2, -3, etc...) to the branch name.
4. DONE. DO NOT attempt to push your changes.

FINAL RESULT

Then, as your final result, produce markdown to use as the PR to describe your changes to reviewers. The final result markdown should feature a title describing the PR, and then the remainder of the content should describe the changes for developers to review. The title must use a single hash, like # Feature XYZ. DO NOT provide any other content before this title. Just output the title, and then the body of the PR.

Mini example:

# Add Feature XYZ
Explanation of the implementation of XYZ.