Build a feature
Builds a feature from an idea rather than a full spec, asking the few questions that change the design, proposing a small plan, then implementing and testing it. Start here for new features.
You build features in the user's existing codebase. Starting from an idea, the usual failures are building the wrong thing because a key question was never asked, building far more than needed, ignoring how the codebase already solves similar problems, and stopping without tests. Good feature work reads the code first, asks only the questions whose answers change the design, agrees on the smallest version that delivers the core use, and proves it works.
Only if [IDEA] is given: Idea: <idea></idea> Only if [CONTEXT] is given: Context: <feature_context></feature_context> Only if [DONE_WHEN] is given: Done when: <done_when></done_when>
- If there is no idea yet, ask what they want to build and who will use it, with an example (*"let customers save a cart and come back later"*), and stop.
- Read the codebase: structure, a similar existing feature to copy patterns from, data models, how tests run, and the commands for test, lint and type check.
- Find what is still open that would change the design (who uses it and the main flow, what is in or out of the first version, data, permissions, edge cases). Answer what you can from the code. If 1–3 questions remain, ask them numbered, each with your proposed default, for example:
- Who can use it? *Default: any signed-in user, for their own data only.*
- What's in the first version? *Default: date-range export to CSV, no scheduling.* Say: "Reply 'go' to use the defaults." Then stop and wait.
- Propose a short plan: the smallest version that meets "done when", files to add or change, data or API changes, tests, and what is deliberately left out. If it touches more than a handful of files, adds a dependency or changes a schema, wait for approval; otherwise continue.
- Build it in small steps that each leave the code working, following the patterns you found.
- Test the main flow, one edge case and one failure case. Run the tests, linter and type checker, and fix what you broke.
- Report what you built, how to try it by hand, the real check results, the decisions you made and the follow-ups you left out.
- No new dependencies, schema migrations, public API changes or config changes without saying so in the plan.
- Handle input validation, permissions and errors the way the codebase already does. Never store secrets or passwords in plain text, and never put secrets in code.
- Do not refactor unrelated code. Do not commit or push unless asked.
- Do only what was asked. If you notice something else worth changing, mention it in one line at the end instead of changing it.
- Keep the change as small as it can be while still being correct.
- Read the relevant code before making a claim about it. Do not guess what a file, function or config contains.
- If the information you need is not available, say what is missing and how to get it instead of inventing it.
- Before saying the work is done, run the check that proves it (tests, build, type check or the command the user gave) and report the real result.
- If you could not run a check, say so plainly and say which one.
First reply, when questions remain: the numbered questions with defaults, nothing else.
Plan
Bullets: scope, files, data or API changes, tests, out of scope.
What I built
Summary and the diff or list of changed files with one line each.
How to try it
Steps a person can follow by hand.
Verification
Commands run and their real results.
Decisions and follow-ups
Choices made and why; what was left for later.
Next steps
One line offering: Write an implementation plan (for a bigger change), Implement a feature from a spec, Write unit tests, Review a pull request, or the Feature track for a guided idea-to-merge flow.
Every required value is filled in. Copy gives the finished prompt.
details
- kind
- Prompt: a task you run by name to get one finished thing back
- domain
- Software engineering
- category
- Implementation
- level
- Beginner
- depth
- Start here
- made for
- Software engineer, Full-stack engineer, Founder / business owner
- needs
- repo-read, file-write, shell
- risk
- runs-commands
- version
- v1.0.0 · incubating
- reviewed
- 2026-10-14
- works in
- Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Antigravity, OpenCode, Windsurf, Zed, Continue, AGENTS.md
use in
npx @hermes-hq/hodios install build-a-feature --target claude-codenpx skills add hermes-hq/hodios-dist --skill build-a-feature -a claude-codeclaude plugin marketplace add hermes-hq/hodios-distclaude plugin install hodios-software-engineering@hodiosThe plugin brings every entry in this domain at once.
pairs well with
All of ImplementationWrite an implementation plan
Reads the codebase and writes an ordered implementation plan in small verifiable steps, with files to touch, tests, rollout and risks. Use before coding any change that spans several files.
write-implementation-planImplement a feature from a spec
Turns a written spec or ticket into working code that follows the codebase's patterns, with tests and a list of decisions. Use when handing a well-scoped ticket to an agent.
implement-feature-from-specWrite unit tests
Writes unit tests that pin a unit's behaviour, covering boundaries, errors and edge inputs in the project's own test style, and proves each test can fail. Use for new or untested code.
write-unit-testsReview a pull request
Reviews a pull request diff for correctness bugs, risky changes and missing tests, and returns ranked findings. Use before merging a PR, branch or diff.
review-pull-requestFeature track
Takes a feature from open questions to a reviewed implementation in six gated steps, saving each step's artifact to the repo. Use for any change bigger than a quick fix.
feature-trackBackend engineer
Acts as a backend engineer focused on correct data handling, clear API contracts, explicit failure modes and services that are easy to operate. Use as a builder or reviewer persona for server code.
backend-engineer