hermes
2,107 entries · 25 categories

Software engineering

Building, reviewing, running and maintaining software, and maintaining open-source projects.

1944 prompts, 63 personas, 25 workflows, 75 rules

Start here

29 start here · 1,682 specific · 396 advanced
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

Categories

Planning64Turning a goal into ordered engineering work: breakdowns, implementation plans, estimates, feature tracks.Product (engineering)47Requirements written for an engineering team to build: PRDs, user stories, acceptance criteria, specs.Architecture92System and API design, boundaries, trade-offs and architecture decision records.Implementation163Writing new code: features, endpoints, scripts, components, scaffolds, regexes and one-off utilities.Code review92Reviewing diffs and pull requests for defects, risk and missing tests.Debugging103Finding and fixing the cause of a defect, crash or failing build.Testing101Writing, fixing and strengthening automated tests.Refactoring93Changing structure without changing behaviour: extract, rename, simplify, remove dead code.Migration104Upgrading dependencies, languages, frameworks and platforms.Performance90Profiling, load testing and making software faster or leaner.Security99Threat modelling, secure review, hardening and supply-chain safety.Accessibility65Making software usable by everyone: audits, ARIA, contrast, keyboard and screen readers.Data engineering99Building data systems: schemas, SQL performance, pipelines, migrations of data.AI and ML engineering102Building with models: LLM apps, RAG, evals, agents, training and MLOps.DevOps101CI/CD, containers, infrastructure as code, cloud and release plumbing.Incident and operations65Alerts, on-call triage, mitigation, runbooks, observability and postmortems.Git and version control88Commits, branches, merges, pull request descriptions and history.Documentation89READMEs, API references, code comments, changelogs and developer guides.Developer writing58Prose by and for developers that is not documentation: RFC prose, tech blog posts, release announcements, clarity rewrites.Learning to code64Understanding code and concepts: explaining codebases, tutoring developers, onboarding.Conventions68Coding standards and style guides for a language or framework, usually rules.Localization (software)65Internationalising software: string extraction, ICU messages, locale formats, translation files.Coding-agent operations62Running coding agents well: handoffs, agent instruction files, context management, multi-agent setups.Security operations67Detecting and responding to attacks: detection rules, SOC triage, phishing and email analysis, forensics, threat hunting, incident playbooks, vulnerability management and CTF practice.Open source maintenance66Running an open-source project: issue and PR triage, contributor guides, governance, licensing choices, releases and changelogs for the community, funding and maintainer burnout.

Download all 2,107

Every entry in software engineering, ready for your tool. Free, CC0.

or install it as a claude code plugin

claude plugin marketplace add hermes-hq/hodios-dist
claude plugin install hodios-software-engineering@hodios

The plugin carries the prompts, personas, workflows and styles. Rules are always-on instructions, so add those from their own pages.

Start with these

A few from each category. Open a category for all of them.

Planning

All 64
  • Write an implementation plan
    PromptPlanning

    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.

  • 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.

  • 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.

  • Break down an epic
    PromptPlanning

    Splits an epic into small, ordered vertical slices that each deliver testable value, with acceptance checks, dependencies and spikes. Use when an epic or large feature is too big to start.

Product (engineering)

All 47
  • 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 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.

  • 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.

  • Write a PRD

    Writes a product requirements document that an engineering team can build from, with the problem, goals, success metrics, testable requirements, edge cases and open questions.

Architecture

All 92
  • 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.

  • 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.

  • Design an API contract

    Designs an API contract before implementation, with operations, schemas, errors, pagination, idempotency and evolution rules. Use when adding an API that other teams or clients will call.

  • API design track
    WorkflowArchitecture

    Takes a new API from consumer needs to a resource model, a reviewed contract, error and versioning rules, and a mock with contract tests, pausing for approval between steps.

Implementation

All 163
  • 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.

  • 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.

  • Frontend engineer

    Acts as a frontend engineer who balances UX, accessibility, performance and maintainable components, and checks work in a real browser. Use to build or review web UI.

  • Game developer

    Acts as a game developer who prototypes fast, tunes game feel through playtesting, keeps every system inside the frame budget and scopes ruthlessly to ship. Use for gameplay code in any engine.

Code review

All 92
  • 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.

  • 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.

  • Review AI-generated code

    Reviews code written by an AI assistant for hallucinated APIs, over-engineering, swallowed errors, weakened tests and copy-paste drift. Use before merging a change an agent produced.

  • Review error handling

    Reviews failure paths for swallowed errors, lost context, unsafe retries, missing timeouts and internal details leaking to users, with ranked fixes. Use on code that calls I/O or external services.

Debugging

All 103
  • Fix a bug
    PromptDebugging

    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.

  • 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.

  • Explain a stack trace
    PromptDebugging

    Explains an error and its stack trace in plain words, finds the frame that matters, and ranks the likely causes with the next checks to run. Use when an exception or crash is hard to read.

  • Debug a production-only bug
    PromptDebugging

    Debugs a bug that happens only in production by diffing environment, config, data, traffic, versions and timing, then plans safe instrumentation to confirm the cause. Use for works-on-my-machine bugs.

Testing

All 101
  • 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.

  • 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.

  • Review test quality
    PromptTesting

    Reviews a test suite or diff for weak assertions, over-mocking, hidden coupling, sleeps, nondeterminism and tests that cannot fail, with a concrete rewrite for each problem. Use when reviewing tests.

  • Test-writing rules

    Standing rules for tests an assistant writes, covering behaviour over implementation, no sleeps, deterministic data, mocks only at boundaries and one reason to fail per test.

Refactoring

All 93
  • 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.

  • Simplify a complex function

    Rewrites a hard-to-follow function into a clearer one with identical behaviour, using guard clauses, named steps and simpler conditions, verified by tests. Use on long or deeply nested code.

  • Extract a module

    Moves one responsibility out of a large file or class into its own module in small, test-verified steps, without changing behaviour or the public API. Use when a file does too many things.

  • Reduce code duplication

    Finds duplicated logic, separates true duplication from code that only looks alike, and merges only true duplicates behind one well-named function. Use when one fix keeps landing in many places.

Migration

All 104
  • 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.

  • Migrate JavaScript to TypeScript
    PromptMigration

    Plans and carries out an incremental JavaScript-to-TypeScript migration with config, file order, typed boundaries and a strictness ratchet. Use to move a JS codebase without a freeze.

  • Plan a breaking API version change
    PromptMigration

    Plans a breaking API version change with a deprecation timeline, compatibility shims, a client migration guide and adoption telemetry. Use before changing anything clients rely on.

  • Upgrade a project's language runtime
    WorkflowMigration

    Upgrades a language runtime across code, lockfiles, Docker images, CI and docs, fixing deprecations and running the full suite at each gate. Use before a runtime version reaches end of life.

Performance

All 90
  • 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.

  • 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.

  • Reduce JavaScript bundle size

    Measures a web app's JavaScript bundles, finds the largest avoidable contributors, and shrinks them with verified changes ranked by bytes saved. Use when page load is slow or a size budget is blown.

  • Improve Core Web Vitals

    Diagnoses poor Core Web Vitals (LCP, INP, CLS) from a Lighthouse, field-data or trace report and ranks fixes by expected improvement. Use when a page fails the vitals thresholds.

Security

All 99
  • Check an app for security problems
    PromptSecurity

    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.

  • Respond to a leaked secret
    PromptSecurity

    Produces an ordered response plan for an exposed key, token or password - revoke and rotate, audit use, clean up copies, notify and prevent. Use right after a secret is committed, logged or shared.

  • Threat model a feature
    PromptSecurity

    Builds a threat model for one feature or change, mapping data flows and trust boundaries to ranked threats and mitigations. Use during design, before the code is written or merged.

  • Triage dependency vulnerabilities
    PromptSecurity

    Triages dependency scan findings by reachability and exploitability, gives the upgrade path, and justifies anything safe to defer. Use when a scanner reports more than the team can fix at once.

Accessibility

All 65
  • 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.

  • Accessibility specialist

    Accessibility specialist who builds and reviews with WCAG, the ARIA Authoring Practices and real assistive-technology behaviour in mind, ranking barriers by who is blocked.

  • Frontend accessibility rules

    Standing rules that make an assistant write accessible frontend code, with semantic HTML first, labels, keyboard and focus handling, contrast, motion and ARIA only where native elements fall short.

  • Write alt text for images

    Writes context-aware alt text for images on a page or in a document, or marks them decorative, following the W3C alt decision tree. Use when publishing images on the web.

Data engineering

All 99
  • 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.

  • Generate realistic seed data

    Generates realistic, referentially consistent fixture data for a database schema, with labelled edge cases and no real personal data. Use for local development, demos and integration tests.

  • Write a data dictionary

    Writes a data dictionary for database tables with each column's meaning, units, nullability, allowed values, owner and lineage, and flags every column it cannot infer. Use when documenting a schema.

  • Database migration rules

    Standing rules for schema migrations an assistant writes, keeping them backward compatible, reversible, lock-aware, batched for data changes and tested on realistic data sizes.

AI and ML engineering

All 102
  • 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.

  • Plan a machine-learning experiment

    Plans a machine-learning experiment before any training code exists: framing, baselines, leak-proof splits, metrics, ablations and a stop rule. Use when starting a new model or modelling spike.

  • Write a model card

    Writes a model card with intended use, training data, metrics by slice, limitations and ethical considerations from training notes and eval results, flagging gaps. Use before releasing a model.

  • Review a training dataset sample

    Audits a sample of a labelled dataset for label noise, leakage, duplicates, class imbalance and representation gaps, and gives a concrete fix for each problem. Use before training or fine-tuning.

DevOps

All 101
  • 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.

  • Design a deployment strategy
    PromptDevOps

    Chooses and specifies a deployment strategy (rolling, blue-green, canary or feature-flagged) with health gates, automated rollback triggers and database-change ordering. Use when deploys feel risky.

  • Review a Dockerfile
    PromptDevOps

    Reviews a Dockerfile for security, image size, build cache use and runtime correctness, and returns ranked findings with a corrected file. Use before shipping an image, or when one is too big.

  • DevOps engineer
    PersonaDevOps

    Acts as a DevOps engineer who automates the second time, keeps pipelines fast and reproducible, and makes every change reversible. Use for CI/CD, infrastructure and release work.

Incident and operations

All 65
  • 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.

  • Write an incident status update

    Writes a clear status update for an ongoing incident, tuned to customers, internal teams or executives, without speculation or promises the team cannot keep. Use for status pages, Slack and email.

  • Write a blameless postmortem

    Turns incident notes, chat logs and timelines into a blameless postmortem with impact, timeline, contributing factors and owned action items. Use after an incident is resolved.

  • Incident commander

    Runs a live incident like an experienced incident commander, assigning roles, keeping a steady comms cadence and driving mitigation before root cause. Use as the coordinating voice during an outage.

Git and version control

All 88

Documentation

All 89
  • 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 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 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.

  • 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.

Developer writing

All 58
  • Write about a technical topic

    Drafts a technical post, announcement, proposal or explainer for a named audience, leading with the main point and inventing no facts. Use when you need to write about engineering work.

  • Rewrite for clarity

    Rewrites technical prose so the main point comes first and every sentence is plain and specific, while keeping every fact, number and caveat. Use on design notes, emails, RFC drafts and docs.

  • Developer advocate

    Acts as a developer advocate who earns attention by teaching, builds demos that work on the first try, carries user feedback back to maintainers and discloses affiliation every time.

  • Write a conference talk proposal

    Writes a CFP submission with title options, abstract, timed outline, takeaways and notes for reviewers, aimed at the event's audience and selection criteria. Use for engineers and developer advocates.

Learning to code

All 64
  • 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 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.

  • 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.

  • Explain a SQL query

    Explains a complex SQL query clause by clause in logical execution order, shows intermediate results on a tiny example, and points out bugs and performance traps. Use when inheriting a query.

Conventions

All 68
  • 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.

  • Tailwind CSS rules

    Standing rules for Tailwind CSS covering design tokens in the theme, class ordering, extracting components instead of repeated class strings, responsive and dark variants and visible focus states.

  • HTTP API design rules

    Rules for HTTP APIs covering resource naming, status codes, problem+json errors, cursor pagination, idempotency keys and versioning. Load when designing or changing HTTP endpoints.

  • C# style rules

    Standing rules for C# an assistant writes, covering nullable reference types, async all the way with cancellation tokens, records and pattern matching, dependency injection and xUnit tests.

Localization (software)

All 65

Coding-agent operations

All 62
  • 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 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 an AGENTS.md

    Writes or updates a repository's AGENTS.md with the verified commands, layout, conventions and boundaries a coding agent needs, and nothing generic. Use when setting up a repo for coding agents.

  • Write an agent skill

    Writes a reusable agent skill (SKILL.md with frontmatter, steps, scripts and references) from a repeated task, with a trigger description models can match and a test plan. Use to package a workflow.

Security operations

All 67
  • Investigate a suspected hack

    Guides the first hours after a suspected attack, covering what to do now, preserving evidence, finding what happened, containing it and who to tell. Use when you think a system or account was hacked.

  • Assess ransomware readiness

    Assesses how ready an organisation is to prevent and recover from ransomware - backups, restores, identity, exposure, admin access, detection and response - and gives a ranked fix list.

  • SOC analyst

    Acts as a seasoned security operations analyst who triages on evidence, documents everything, escalates early when impact is possible and stays calm under alert floods.

  • Write a security awareness module

    Writes a short security awareness module for staff on one topic, such as phishing, MFA fatigue or safe file sharing, with realistic examples, clear actions, a quiz and a one-page reminder.

Open source maintenance

All 66
  • 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.

  • 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.

  • Open-source launch track

    Takes an open-source project from readiness fixes to a channel plan, per-channel drafts, a launch-day run sheet and a two-week review, pausing for the maintainer's approval between steps.

  • Triage an issue backlog

    Triages a batch of issues for maintainers with duplicates, labels, severity, needs-info replies and what to close. Use when the tracker grows faster than the team can read it.