hermes

Start here 1

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.

Search and filter in Implementation
  • 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.

Specific 129

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

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

  • Implement transactional email

    Implements transactional email with templates, a provider integration, retries, bounce and complaint handling, and deliverability settings. Use when an app must send receipts, resets or alerts.

  • Integrate payments

    Implements a payment integration with the provider's official SDK, covering checkout, webhooks, idempotency, refunds and reconciliation. Use when adding one-time payments or subscriptions.

  • Mobile engineer

    Acts as a mobile engineer who designs for flaky networks, battery and memory limits, platform conventions and app-store releases. Use for iOS, Android or cross-platform work.

  • Build a webhook handler

    Implements a webhook receiver with signature checks, replay protection, idempotent processing, fast acknowledgement, async work, retries and tests. Use when integrating Stripe, GitHub or similar.

  • Implement a background job

    Implements a background or scheduled job with idempotency, retries with backoff, dead-letter handling, timeouts, concurrency limits and observability. Use to move slow work off the request path.

  • Implement secure file uploads

    Implements secure file uploads with direct-to-storage signed URLs, type and size validation, a malware-scan hook, safe naming and orphan cleanup. Use for backends accepting user files.

  • Implement a state machine

    Models a business process such as an order, booking or approval as an explicit state machine with states, transitions, guards and side effects, then implements it with exhaustive tests.

  • Integrate a third-party API

    Implements a typed client for a third-party HTTP API from its docs, with auth, pagination, retries, rate limits and a test fake. Use when wiring an external service into your code.

  • Write a command-line tool

    Designs and implements a small command-line tool with subcommands, help text, exit codes, config precedence and tests. Use when turning a manual workflow into a reusable command.

  • Write a regular expression

    Builds a regular expression from plain-language intent and example strings, explains each part and lists the edge cases it accepts or rejects. Use when you need a tested pattern.

  • Flutter engineer

    Acts as a senior Flutter engineer in Dart who composes widgets cleanly, picks one state management approach and keeps to it, handles platform differences and tests widgets.

  • Python engineer

    Acts as a senior Python engineer who writes typed, readable code, structures packages cleanly, picks between scripts, services and notebooks deliberately and tests with pytest.

  • Vue engineer

    Acts as a senior Vue engineer who uses the Composition API and single-file components idiomatically, handles reactivity and state carefully and follows Nuxt conventions when present.

  • WordPress developer

    Acts as an experienced WordPress developer who extends sites with child themes, blocks and plugins instead of core edits, keeps sites secure and fast, and explains choices to site owners.

  • Build a personal website

    Builds a simple personal or portfolio website in plain HTML and CSS or a static site generator, accessible, fast and free to host, with steps a beginner can follow. Use to get a site online.

  • Add rate limiting to an API

    Adds rate limiting to API endpoints with a fitting algorithm, keys, per-tier limits, standard headers, 429 responses and tests. Use when protecting endpoints from abuse or overload.

  • Build a reusable UI component

    Builds a typed, accessible UI component from a description or screenshot, with loading, empty and error states and a usage example. Use when adding a component to a frontend.

  • Implement OAuth or OIDC login

    Implements login with an OAuth 2 or OpenID Connect provider, covering flow choice, PKCE, state and nonce, token storage, sessions and logout. Use when adding social or SSO login.

  • Scaffold a new service or library

    Creates the minimal production-ready skeleton for a new service or library (layout, config, lint, tests, CI, README) and justifies each choice. Use when starting a new repo or package.

  • Write a streaming file parser

    Writes a streaming parser and validator for CSV, log, fixed-width or custom text files that reports malformed records with line numbers instead of crashing. Use for messy input files.

  • PHP and Laravel engineer

    Acts as a senior PHP and Laravel engineer who follows framework conventions, keeps controllers thin, uses queues, policies and migrations properly and writes feature tests.

  • Write microcontroller firmware

    Writes firmware for a microcontroller such as an Arduino, ESP32 or RP2040 for a sensor or actuator task, with a wiring table, non-blocking code and a bench test plan. Use for prototype hardware.

  • Write a Python automation script

    Writes a Python script that automates a repetitive file, spreadsheet or web task, with a dry run by default, clear options, logging and setup steps a non-developer can follow. Use for chores.

  • Full-stack engineer

    Acts as a full-stack engineer who builds features end to end, from schema and API to UI, keeps the contract between layers explicit and ships thin vertical slices. Use for features spanning the stack.

  • Generate procedural levels

    Implements procedural level or map generation with a fitting algorithm, seeded and reproducible, with playability constraints and a validator that rejects broken output before a player sees it.

  • Implement threaded comments

    Implements threaded comments with replies, cursor pagination, edit and delete rules, id-based mentions, deduplicated notifications and moderation hooks, end to end.

  • Implement drag-and-drop reordering

    Implements drag-to-reorder lists and boards with persisted order via fractional keys, optimistic updates with rollback, concurrent-move handling and a keyboard alternative.

  • Implement form validation

    Implements form validation on client and server from one shared schema, with accessible errors, inclusive rules for names and addresses, a server error contract and tests. Use when building forms.

  • Implement magic-link sign-in

    Implements passwordless email magic-link sign-in with single-use expiring tokens, protection from link scanners, safe redirects and rate limits. Use to add email-link login.

  • Implement pagination

    Implements cursor or offset pagination for an API and its UI with a stable sort order, enforced limits, a matching index and tests for the boundary cases. Use when a list endpoint returns too much.

  • Implement PDF generation

    Implements PDF generation for invoices, reports or certificates from templates, with embedded fonts, controlled page breaks, accessibility tags where possible and output tests.

  • Implement real-time updates

    Implements real-time updates with WebSockets, server-sent events or polling, choosing the simplest transport that fits, with reconnection, resync, authorisation and scaling notes. Use for live UIs.

  • Implement subscription billing

    Implements recurring subscriptions with a billing provider covering plans, trials, upgrades with proration, failed-payment dunning and entitlements synced by webhooks. Use for SaaS plans.

  • Write a robust shell script

    Writes a portable shell script with strict mode, argument parsing, a dry-run flag, clear errors and idempotent steps. Use when automating a chore you will run more than once.

  • Put a change behind a feature flag

    Wraps new behaviour behind a feature flag with a safe default, a kill switch, tests for both paths and a cleanup ticket. Use when shipping a risky change incrementally.

  • Build a REST endpoint end to end

    Implements one HTTP endpoint with route, input validation, handler, error mapping and tests in the project's own framework and conventions. Use when adding an API route.

  • Prototype a browser game

    Prototypes a small browser game with a fixed-timestep loop, input handling, collisions, scoring and placeholder art, in plain JavaScript or a light engine. Use to test whether a game idea is fun.

  • Write a sensor driver

    Writes a driver for an I2C or SPI sensor from its datasheet, with a register map, init sequence, unit conversion, bus error handling, non-blocking reads and a hardware test.

  • 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 product analytics tracking

    Implements typed product analytics events from a tracking plan with one wrapper, consent gating, identity stitching, no personal data and validation in development. Use to instrument an app.

  • Implement API key authentication

    Implements API keys for an API with shown-once issuance, hashed storage, prefixes, scopes, rotation, revocation and last-used tracking. Use when machines or customers call your API.

  • Implement appointment slot booking

    Implements bookable time slots from availability rules with time zones, DST, buffers and notice periods, and prevents double booking under concurrency. Use for appointment or reservation apps.

  • Implement an audit log

    Implements an append-only audit log of who did what and when, with a schema, a transactional write path, tamper evidence, retention and an admin query view.

  • Implement a CSV import

    Implements a CSV or spreadsheet import with streaming parsing, per-row validation, a downloadable error report, idempotent upserts and progress for large files.

  • Implement email address verification

    Implements email verification with hashed single-use expiring tokens, scanner-safe links, resend limits, safe change-of-email and clear rules for unverified accounts.

  • Implement game AI behaviour

    Implements enemy or NPC behaviour with a fitting technique (state machine, behaviour tree, utility AI or GOAP), perception, pathfinding hooks and debug views, tuned for fun over optimal play.

  • Implement an infinite-scroll feed

    Implements an infinite-scroll feed with cursor pagination, an intersection observer trigger, virtualisation for long lists, scroll restoration, deduplication and error retry.

Showing 50 of 129. See them all in search

Advanced 33

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

  • Angular engineer

    Acts as a senior Angular engineer who builds with standalone components and services, uses signals or RxJS where each fits, enforces strict typing and keeps change detection efficient.

  • C++ engineer

    Acts as a senior C++ engineer who uses RAII and the modern standard library, avoids undefined behaviour, measures before optimising and keeps ABI and build concerns in mind.

  • .NET engineer

    Acts as a senior C# and .NET engineer who designs with async and dependency injection, uses nullable reference types, keeps APIs and data access clean and writes testable services.

  • Embedded engineer

    Acts as an embedded engineer who respects hardware limits, reads datasheets before coding, writes deterministic firmware and tests on real devices. Use for microcontroller, RTOS and driver work.

  • Go engineer

    Acts as a senior Go engineer who writes simple, explicit code, handles every error with context, uses contexts and goroutines carefully and reaches for the standard library first.

  • Kotlin Android engineer

    Acts as a senior Android engineer in Kotlin who uses coroutines and flows correctly, builds declarative UI, respects the lifecycle and battery, and tests view models and UI.

  • React engineer

    Acts as a senior React engineer who keeps components small and state close to its use, derives rather than duplicates state, gets effects and data fetching right and tests behaviour.

  • React Native engineer

    Acts as a senior React Native engineer who shares code without ignoring platform differences, manages native modules and builds, optimises lists and startup and tests on devices.

  • Rust engineer

    Acts as a senior Rust engineer who designs around ownership and lifetimes, uses explicit error types, keeps unsafe small and documented, and leans on clippy and tests.

  • Swift iOS engineer

    Acts as a senior iOS engineer in Swift who favours value types and structured concurrency, builds accessible SwiftUI, follows platform conventions and profiles before optimising.

  • TypeScript engineer

    Acts as a senior TypeScript engineer who models domains with precise types, avoids any, validates data at runtime boundaries and keeps Node, browser and build concerns apart.

  • Elixir and Phoenix engineer

    Acts as a senior Elixir and Phoenix engineer who designs with processes and supervision trees, uses pattern matching and immutability, and applies LiveView and contexts where they fit.

  • Java and Spring engineer

    Acts as a senior Java and Spring engineer who builds layered services with clear boundaries, uses dependency injection sensibly, handles transactions carefully and writes integration tests.

  • Concurrency specialist

    Acts as a concurrency specialist who designs and reviews async, multi-threaded and distributed code for races, deadlocks and lost updates, and proves fixes with stress tests rather than sleeps.

  • Graphics programmer

    Acts as a graphics programmer who knows the rendering pipeline, shaders, draw-call budgets, GPU profiling, lighting and colour spaces, and trades quality against frame time on target hardware.

  • HDL design engineer

    Acts as an FPGA and digital logic engineer who writes synthesisable Verilog, SystemVerilog or VHDL, thinks in clock domains and timing closure, and simulates with testbenches before hardware.

  • Implement multiplayer netcode

    Chooses a netcode model for a game, such as authoritative server with prediction, rollback or lockstep, and implements tick rate, reconciliation, lag compensation and cheat limits.

  • Implement offline-first sync

    Implements offline-first sync for a mobile or web app with a local store, a mutation outbox, a server-ordered change feed, an explicit conflict policy and safe retries. Use for apps used offline.

  • Implement recurring events

    Implements recurring events with RRULE storage, time-zone and DST-correct expansion, cancelled and edited occurrences, this-and-following edits and range queries.

  • Embedded board bring-up track

    Brings up a new board or prototype in gated steps, from power and clocks to debugger and blinky, a UART console, each peripheral with a test, and a bring-up report for the hardware team.

  • Implement undo and redo

    Implements undo and redo with a command or patch history, grouping of related changes, a size limit, keyboard shortcuts, selection restore and correct interplay with saving.

  • Implement per-plan usage quotas

    Implements per-plan usage limits with race-free metering, enforcement before costly work, threshold warnings, period resets, plan changes and overage handling.

  • Implement access and refresh tokens

    Implements short-lived JWT access tokens with rotating refresh tokens, reuse detection, revocation and safe client storage. Use when an API or mobile app needs token-based sessions.

  • Add low-power sleep modes

    Adds sleep modes to battery firmware, gating clocks and peripherals, choosing wake sources and state retention, and backs the change with a current measurement plan and battery-life budget.

  • Build a GraphQL server

    Implements a GraphQL server from a schema with resolvers, per-request DataLoader batching, field-level authorisation, error mapping and query limits. Works with Apollo, Strawberry or graphql-java.

  • Implement desktop app auto-update

    Implements auto-update for an Electron or Tauri app with signed releases and verified updates, update channels, staged rollout, a non-disruptive restart prompt and a recovery plan.

  • Implement a firmware bootloader

    Implements or configures a microcontroller bootloader with a flash layout, verified image header, safe jump to the application, field updates and recovery from an interrupted update.

  • Implement an interrupt-safe buffer

    Implements a lock-free single-producer single-consumer ring buffer between an interrupt handler and the main loop or an RTOS task, with correct barriers, an overflow policy and tests.

  • Implement a Bluetooth LE peripheral

    Implements a Bluetooth Low Energy peripheral with a GATT design, notifications, pairing and bonding choices, MTU and battery-aware connection parameters, plus a phone-side test plan.

  • Implement an access-token refresh interceptor

    Implements an HTTP client interceptor that attaches access tokens, refreshes once on 401 with a single shared request, queues concurrent calls, retries them and logs out cleanly on failure.

  • Implement idempotency keys for an API

    Makes POST endpoints safe to retry with Idempotency-Key storage, request fingerprints, locking and replayed responses. Use when retries or double clicks create duplicate orders or charges.

  • Add biometric unlock to a mobile app

    Adds Face ID, Touch ID or Android biometric unlock backed by Keychain or Keystore so biometrics unlock a stored credential, with fallbacks, enrolment changes and opt-in handled.

  • Add enterprise SSO with SAML or OIDC

    Adds per-customer enterprise single sign-on with SAML or OIDC, domain routing, verified domains, JIT provisioning and strict assertion checks. Use when B2B customers ask for SSO.

Not: changing structure without behaviour (refactoring); fixing a defect (debugging); writing tests (testing).