hermes

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.

context

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>

task
  1. 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.
  2. 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.
  3. 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:
  4. Who can use it? *Default: any signed-in user, for their own data only.*
  5. 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.
  6. 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.
  7. Build it in small steps that each leave the code working, following the patterns you found.
  8. Test the main flow, one edge case and one failure case. Run the tests, linter and type checker, and fix what you broke.
  9. 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.
constraints
  • 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.
output format

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

Edit on GitHubReport a problem

use in

Hodios CLI
npx @hermes-hq/hodios install build-a-feature --target claude-code
Agent Skills
npx skills add hermes-hq/hodios-dist --skill build-a-feature -a claude-code
Add the Hodios marketplace (once)
claude plugin marketplace add hermes-hq/hodios-dist
Install the software-engineering plugin
claude plugin install hodios-software-engineering@hodios

The plugin brings every entry in this domain at once.

pairs well with

All of Implementation
PromptPlanning

Write 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-plan
PromptImplementation

Implement 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-spec
PromptTesting

Write 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-tests
PromptCode review

Review 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-request
WorkflowPlanning

Feature 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-track
PersonaImplementation

Backend 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