Coding-agent operations
Running coding agents well: handoffs, agent instruction files, context management, multi-agent setups.
Download all 62
- Review a coding agent transcript
Reviews a coding agent session transcript for where it went wrong (bad assumptions, skipped verification, scope creep, looping) and turns each failure into an instruction-file or prompt change.
- 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 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.
- 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 a subagent brief
Turns a task into a self-contained brief for a subagent or parallel agent, with the goal, context, scope, constraints, return format and definition of done. Use before delegating to another agent.
- Add agent-friendly dev commands
Adds fast, quiet, non-interactive commands to run one test, type-check or lint changed files and build, so coding agents get quick readable feedback instead of long noisy runs.
- Agent-ready repository track
Prepares a repository for coding agents in four gated steps, from a timed setup audit and verified instruction files to least-privilege guardrails and a trial task that tests them.
- Assess coding agent impact on a team
Reads a team's data on agent-assisted work, such as cycle time, review load, reverts, incidents and survey answers, and judges what coding agents actually changed, with confounders named.
- Decide how to delegate a task to an agent
Judges whether a coding task should run unattended on an agent, be done with an agent in a supervised session, or be done by hand, from verifiability, blast radius, ambiguity and context needs.
- Audit a coding agent's permissions
Reviews a coding agent's tool, permission and sandbox configuration for shell, network, secrets and write-scope risk, and proposes least privilege. Use before giving an agent more autonomy.
- Audit an MCP server before installing it
Vets a third-party MCP server before you install it, covering publisher, version pinning, what each tool can do, poisoned tool descriptions, network use and credentials.
- Benchmark coding agents on a repo
Builds a small benchmark from closed issues and their fixing commits to compare coding agents or settings, with task selection, hidden-test grading, cost and time capture and result reading.
- Break an agent's failing fix loop
Breaks a coding agent out of a loop of failed fixes by stopping edits, listing the hypotheses already tried, gathering real evidence and choosing a different approach or a reset.
- Careful coding agent
Acts as an autonomous coding agent that reads before editing, keeps diffs small and in scope, verifies with the project's own commands and asks before anything irreversible. Use for agent sessions.
- Check agent instructions for stale claims
Verifies every command, path, version and convention claimed in a repo's agent instruction files against the code, fixes the wrong ones and adds a CI check that catches drift.
- Choose a coding agent for a team
Shortlists coding agent tools for an engineering team by working style, data handling, admin controls, model options, cost model and fit with the codebase, then designs a fair two-week trial.
- Choose MCP servers for a project
Picks which MCP servers a coding agent should connect for a project, with scope, read-only modes, credential handling, trust checks and the context cost of each server's tool list.
- Consolidate agent instruction files
Merges a repository's scattered instruction files for different coding agents into one canonical source with thin per-tool files, resolved conflicts and a guard against drift.
- Cut coding agent spend
Finds where a person's or team's coding agent spend goes and cuts it through model choice per task, leaner context, fewer retries and trimmed tools, measured per merged change.
- Debug agent skills, commands and hooks
Diagnoses why an agent skill, custom command, subagent or hook never triggers or fails, checking file location, frontmatter, descriptions, matchers, permissions and exit codes.
- Debug an MCP server connection
Diagnoses why a coding agent cannot connect to or use an MCP server, from config location, stdio or HTTP transport and env vars to auth, timeouts and logs.
- Define a specialist subagent
Writes a reusable subagent definition with a routing description, a narrow tool list, a focused system prompt and a short return format, for a recurring role such as test runner or reviewer.
- Design agent memory notes
Designs how a coding agent keeps durable notes across sessions, covering what is worth recording, where notes live, their format, who may write them and when they are pruned.
- Design an agent implement-and-review loop
Designs a loop where one coding agent implements and another reviews, with review criteria, an iteration cap, the feedback format, oscillation checks and when a human steps in.
- Design a sandbox for coding agents
Designs an isolated container or VM for running coding agents with less supervision, covering mounts, network egress allowlist, credentials, resource limits and how work leaves the box.
- Design a CI coding agent job
Designs a coding agent job that runs in CI on issues, pull requests or a schedule, with trigger rules, token scopes, untrusted-input handling, cost caps, outputs as pull requests and a kill switch.
- Design coding agent hooks
Designs lifecycle hooks for a coding agent, such as formatting after edits, blocking dangerous commands, fast tests before stopping and context at session start, kept fast and debuggable.
- Diagnose a failing agent environment
Diagnoses why a cloud or container coding agent cannot install, build or test the repo, from network egress, proxies and certificates to missing tools, secrets, architecture and limits.
- Document UI components for agents
Writes a compact catalog of a codebase's UI components, props, variants and usage rules so coding agents reuse them instead of inventing new markup, styles or near-duplicate components.
- Decide what to hide from coding agents
Works out which files a coding agent should not read or index, such as secrets, customer data, generated code and large artefacts, and writes the ignore and deny rules with their limits stated.
- Fix an instruction an agent keeps ignoring
Diagnoses why a coding agent keeps ignoring a rule in its instruction file, from burial and conflicts to vagueness or lost context, and fixes it with a rewrite, a move or an enforced check.
- Give an agent read-only production access
Designs safe read-only access for a coding agent to production logs, metrics and data for debugging, with scoped roles, masked views, query limits, short-lived credentials and audit.
- Guard against hallucinated packages
Stops coding agents from installing hallucinated or typosquatted packages, using instruction rules, install approval, registry controls, lockfile review in CI and install script limits.
- Make an issue agent-ready
Rewrites a human-written ticket into an issue a coding agent can finish unattended, with goal, files, constraints, acceptance tests, out-of-scope list and stop rules, plus a readiness verdict.
- Plan context for a long agent task
Plans how a coding agent works through a long task without losing the plot, with a task ledger, checkpoint notes, what to keep in context, what to re-read and when to hand off.
- Migrate a repo's coding agent setup
Moves a repository's setup from one coding agent to another, mapping instruction files, scoped rules, commands, MCP servers, hooks and ignore files, and flagging what has no equivalent.
- Turn review comments into agent rules
Mines repeated human review comments on agent-written pull requests and turns each recurring correction into an instruction rule, a lint or test check, or a note that it needs human judgement.
- Pack repo context for a chat assistant
Selects and bundles the files, tree and summary a chat assistant needs to answer one coding question, within a token budget and with secrets and irrelevant files left out.
- Package an agent plugin
Packages a team's agent commands, skills, subagents, hooks and MCP config into a versioned plugin with a manifest, a marketplace entry, a security note and an install test.
- Pick the best of several agent attempts
Compares several coding agent attempts at the same task against the requirements, test evidence, diff size and hidden shortcuts, then picks one to merge, combines parts or rejects them all.
- Plan an agent-driven batch migration
Plans a large repetitive change across many files done by coding agents in batches, choosing codemod or agent per pattern, with a pilot recipe, per-batch checks, a ledger and stop rules.
- Plan a coding agent rollout
Plans rolling out coding agents to an engineering team with pilot tasks, permission levels, review rules, repository preparation, measures of value and a plan for handling failures.
- Plan parallel agent work
Splits a large change into tasks several coding agents can run in parallel worktrees without conflicts, with file ownership per task, interfaces fixed first, merge order and integration checks.
- Prune an agent instruction file
Cuts a bloated AGENTS.md or similar agent instruction file down to the lines that change agent behaviour, removing generic, stale, duplicated and conflicting rules with a reason for each cut.
- Recover from a bad agent session
Triages a coding agent session that went wrong, working out what changed, what to keep, what to undo and how to restart, without losing good work or making the damage worse.
- Resume an interrupted agent task
Reconstructs where an interrupted coding agent task stands from git state, notes and test results, and writes a resume note with done, half-done and next steps before any edits.
- 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.
- Run a coding agent headless from scripts
Writes a script that runs a coding agent non-interactively with a fixed prompt, a narrow permission mode, structured output parsing, timeouts, turn and cost caps, exit codes and logs.
- Run a coding agent on a local model
Sets up a coding agent to run on a local or self-hosted model, with model size chosen by hardware, context length, tool-calling support, configuration and honest expectations.
- Set up audit logging for coding agents
Sets up a team record of what coding agents did, including commands, file changes, network calls, tool use and approvals, with sources, redaction, retention, access and review.
- Set up an isolated database for agents
Gives coding agents an isolated, seeded database per session or worktree so they can run migrations and data tests without touching shared or production databases.
- Set up git checkpoints for agent work
Sets up a git routine for coding agent work with a branch per task, checkpoint commits after each green step, safe ways back to a checkpoint and a clean squash before review.
- Set up UI self-checks for a coding agent
Lets a coding agent check its own UI changes in a real browser, with a dev server recipe, a test account, screenshots at set widths, console and network errors and a requirement check.
- Share agent config across a team
Decides which coding agent settings, permissions, MCP servers, hooks and commands a team commits to the repo and which stay personal, with gitignore entries and safe defaults.
- Triage agent pull requests
Triages a backlog of agent-opened pull requests into merge, fix by hand, re-run with a better brief or close, with the reason, the follow-up and the order to handle them in.
- Verify an agent's completion claims
Checks a coding agent's "done" report against the diff, real test runs and the requirements, flagging unverified claims, skipped steps, weakened tests and work that was never done.
- Write a custom agent command
Turns a request you keep typing into a coding agent into a reusable custom command with named arguments, steps, a definition of done and safe defaults. Use when you repeat the same session opener.
- Write a cloud agent environment setup
Writes the setup for a cloud or container coding agent so it can install, build and test the repo unattended, with pinned versions, preinstalled dependencies, no secrets and a smoke check.
- Write agent-ready issue templates
Writes issue or ticket templates that capture what a coding agent needs by default, such as goal, files, acceptance checks, constraints and test commands, without burdening human reporters.
- Write instructions for an AI code reviewer
Writes the instruction file for an AI pull request reviewer in a repository, saying what to flag, what to ignore, severity levels and comment style, so its reviews are signal rather than noise.
- Write path-scoped agent rules
Writes path-scoped instruction files for coding agents, such as nested AGENTS.md or glob-matched rule files, so each package or file type gets only the rules that apply to it.
- Write a team coding agent playbook
Writes a team's practical guide to coding agents, covering which tasks to hand over, how to brief, review and disclosure rules, data rules and the pitfalls seen in this codebase.
Not: prompt writing for any assistant (prompt-engineering); output tone and length (output-styles).