hermes
1,982 of 10,241 entries

Code prompts

Prompts to code: review, build, test. Start with an essential: it asks a few questions, then gets specific.

Essentials

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
PromptImplementation

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.

build-a-feature
PromptDebugging

Fix a bug

Fixes a bug from a symptom or error, asking what happens, what should happen and how to trigger it if missing, then reproduces it, fixes the cause and proves it. Start here for any bug.

fix-a-bug
PromptData engineering

Design a relational database schema

Designs a relational schema from requirements and access patterns, with keys, constraints, types, indexes and DDL. Use when starting a new service or feature that stores data.

design-database-schema
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
PromptProduct (engineering)

Write user stories

Turns a feature description into small, independent user stories for specific users, each with acceptance criteria, and splits stories that are too big. Use when preparing a backlog.

write-user-stories
PromptSecurity

Check an app for security problems

Runs a first security pass over an app, mapping what is exposed and checking the flaws that most often get apps breached, then ranks the fixes. Use to find out if your app is reasonably safe.

check-app-security
PromptArchitecture

Design a system's architecture

Designs the architecture for a new system or a big new part of one, starting from the requirements that drive it, with components, a diagram, key decisions and risks. Use when starting to design.

design-system-architecture
PromptLearning to code

Explain a piece of code

Explains a piece of code step by step at the reader's level, starting with what it is for, then walking through how it works with a worked example and the parts that are easy to misread.

explain-code

Start here 18

The general, start-from-zero entry for a need in this category: it works from a blank start, asks for what it needs and hands off to the specific entries. Example: Plan a trip.

  • Fix a git problem

    Works out what state your repository is in and gives the safest commands to get where you want, with a backup first and a check after. Use when git confuses you or you are stuck mid-task.

  • Refactor messy code

    Cleans up hard-to-work-with code in small behaviour-preserving steps, pinning behaviour with tests first and fixing what blocks your goal most. Use when code is messy and you want it easier to change.

  • Set up deployment for an app
    PromptDevOps

    Plans how an app gets from the repository to production, choosing hosting that fits, a build-test-deploy pipeline, secrets, rollback and the production basics. Use when you need to ship an app.

  • Write a how-to guide for one task

    Writes a how-to guide for a reader who knows the basics, with a goal-named title, prerequisites, numbered steps with expected results, a verification step and links instead of tangents.

  • Write unit tests
    PromptTesting

    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.

  • Triage a production alert

    Turns a firing production alert into a severity call, the safest mitigation to try first, ranked hypotheses and the next checks. Use in the first minutes of an incident or page.

  • Upgrade a major dependency
    PromptMigration

    Upgrades a library or framework across major versions using the official migration notes, fixes what breaks, and proves the result with before-and-after checks. Use for any breaking upgrade.

  • Write a test plan
    PromptTesting

    Writes a risk-based test plan for a feature or release covering scope, risks, test levels, environments, data, manual checks automation misses and exit criteria. Use before testing a release.

  • Code reviewer

    Reviews changes like a senior engineer who blocks only on real defects, backs every finding with a triggering input, and keeps style opinions out. Use as a reviewer persona or subagent.

  • Debugger
    PersonaDebugging

    Debugs by reproducing first, testing one hypothesis at a time and fixing root causes, never symptoms. Use as a persona or subagent for bugs, crashes and failing builds.

  • Open-source maintainer

    Acts as an experienced open-source maintainer who protects project scope, writes welcoming but firm replies, reviews contributions and keeps releases sustainable.

  • Profile and speed up a hot path

    Measures a slow operation, profiles where the time goes, and makes it faster one verified change at a time, with before-and-after numbers. Use when an endpoint, command or function is too slow.

  • App localisation track

    Takes an English-only app to its first extra language in gated steps, from readiness scan and string extraction to formatting fixes, pseudo-localisation, translation hand-off and linguistic QA.

  • Audit web accessibility against WCAG 2.2

    Audits markup or components against WCAG 2.2 and reports each issue by success criterion with user impact, severity and a concrete code fix. Use before a release or a compliance review.

  • Set up an open-source project

    Gets a project ready to open-source, checking you may publish it, picking a licence, adding the files contributors expect and setting promises you can keep. Use when publishing a project.

  • Add an AI feature to an app

    Turns an AI feature idea into a buildable design, choosing the simplest approach that works and planning evals, guardrails, cost and build steps. Use when you want to add AI or an LLM to your product.

  • Review a coding agent's plan

    Reviews the plan a coding agent proposes before it edits anything, checking its claims against the code, scope, order, verification and risky actions, and returns approve, revise or reject.

  • Write a team coding standards document

    Drafts a team's coding standards from its actual code, lint config and review comments, splitting what tools enforce from what needs judgement, with a reason and example for every rule.

Specific 1,584

One situation, audience, tool or format inside the category. Example: Plan a road trip with children.

All 1,584 in search
  • Explain a codebase

    Explains an unfamiliar codebase. Maps its structure, traces one real request end to end and names the concepts and gotchas a newcomer needs. Use when joining a project or reading an unknown repo.

  • Write acceptance criteria

    Writes testable acceptance criteria for a user story or ticket, covering the main path, alternatives, validation, boundaries, permissions and empty states. Use before a story enters development.

  • Write a README

    Writes or improves a project README from what the code actually does, with an install and quick start that work when copied. Use for a new project or a README that has drifted.

  • Write an agent handoff

    Writes a self-contained handoff note so a fresh agent or a teammate can continue the current task without the conversation history. Use before ending a long session, switching tools or delegating.

  • Write a changelog entry

    Turns the commits and pull requests in a release range into a user-facing changelog entry in Keep a Changelog format, with breaking changes first. Use when cutting a release.

  • Coding mentor

    Acts as a senior developer mentoring a junior, asking what they tried, explaining the why behind fixes and reviewing code to teach. Use for early-career developers who want to grow.

  • Feature track
    WorkflowPlanning

    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.

  • Write release notes

    Turns merged pull requests or commits into release notes for a chosen audience, grouped by impact and written as outcomes without internal jargon. Use when shipping a version.

  • Compare design options

    Compares two to four technical options against the criteria that matter, weighs reversibility and risk, and recommends one. Use when a team is stuck choosing between approaches or tools.

  • Fix N+1 queries

    Finds N+1 database queries behind an endpoint, page or job by counting real queries, fixes them with eager loading or batching, and adds a query-count test so they do not return.

  • Plan a spike
    PromptPlanning

    Turns a technical unknown into a time-boxed spike with a sharp question, exit criteria, cheapest-first experiments and a clear deliverable. Use when an unknown blocks a decision or an estimate.

  • Product manager

    Acts as a product manager who starts from the user problem and evidence, writes requirements engineers can build and test, and cuts scope to the smallest valuable release.

Advanced 371

Expert or deep work that assumes the user can judge expert output. Example: Plan croissant lamination.

All 371 in search
  • Data engineer

    Acts as a data engineer who designs for idempotency, backfills and observability, treats schemas as contracts with their consumers, and asks who depends on each table before changing it.

  • Machine-learning engineer

    Acts as a machine-learning engineer who starts from the data and a baseline, insists on evals and reproducibility, and distrusts any gain a simpler model explains.

  • Software architect

    Acts as a pragmatic software architect who designs from requirements and constraints, names trade-offs and failure modes, and keeps designs as simple as the problem allows.

  • Design a data pipeline

    Designs a batch or streaming data pipeline sized to stated volumes, covering sources, schedule, idempotency, late data, backfills and monitoring. Use before building or replacing a pipeline.

  • Design a star schema

    Designs a dimensional model from the questions analysts need answered: business processes, grain, facts, dimensions, slowly changing dimension types and DDL. Use when building a warehouse layer.

  • Plan an incremental migration
    PromptMigration

    Plans a framework, platform or system migration as small reversible phases using the strangler fig pattern, with data strategy, verification and rollback per phase. Use instead of a big-bang rewrite.

  • Review a system design

    Reviews a design document or proposal for failure modes, scaling limits, data and consistency risks and operability gaps, and returns ranked findings. Use before a design review or before building.

  • Triage a vulnerability report
    PromptSecurity

    Triages an external vulnerability or bug bounty report by checking the claim, rating severity with CVSS, deciding valid, duplicate or out of scope, and drafting the reply. Use for security inboxes.

  • Performance engineer

    Acts as a performance engineer who profiles before optimising, changes one thing at a time and reports gains with numbers and variance. Use for latency, throughput or memory work.

  • Staff engineer

    Acts as a staff engineer who scopes ambiguous cross-team problems, writes the doc that unblocks a decision, weighs organisational cost with technical cost and grows other engineers.

  • Untangle circular dependencies

    Finds circular dependencies between modules and plans breaking each cycle with interfaces, inversion or extraction in safe steps. Use when import cycles cause build errors or tangled code.

  • Write an engineering design doc

    Writes an engineering design doc or RFC with context, goals and non-goals, options and trade-offs, the decision, risks and a rollout plan. Use before building a change that needs review or buy-in.