Four AI Agent Skills That Make Coding Workflows Sharper

AI coding agents are often discussed as though they are a single tool: ask for code, receive code. In practice, useful agent work has stages. You need different behavior when the request is unclear, when a design has to survive scrutiny, when implementation is underway, and when work must move into a new session.

Trying to solve all four stages with one large prompt usually produces a compromise. The agent may be verbose while you need execution, eager while you need questions, or unable to resume work because the important context is buried in chat history.

This article covers four skills that address those distinct problems: Caveman for concise execution communication, Superpowers for structured development, grill-me for pressure-testing a proposal, and handoff for transferring the live thread to a fresh agent or session. They are complementary. The goal is not to add more ceremony to every edit. It is to apply the smallest useful constraint at the moment it prevents the most waste.

The four failure modes of AI-assisted development

1. The agent starts coding before the work is understood. A request such as “add organization roles” hides decisions about membership, permission scope, migrations, audit trails, errors, and rollout. An agent can produce a plausible patch before any of those choices are explicit.
2. The agent agrees instead of challenging. Helpful assistants tend to accept a framing. That is dangerous when the framing is a proposal rather than a settled requirement. You need an interview that exposes dependencies and asks what could fail.
3. The agent talks too much during routine work. Once a direction is approved, long explanations can become friction. During debugging, review follow-ups, and small implementation loops, the useful output is usually a finding, a change, validation, and a risk note.
4. Context is lost at a session boundary. A new agent with no context repeats discovery. A new agent with a full transcript has to find the current state among outdated ideas and tool logs. Neither is a reliable way to continue a task.

The four skills map directly to those problems.

grill-me: challenge the proposal before code

grill-me is a manually invoked skill that interviews you about a plan or design one question at a time. It provides a recommended answer and waits for feedback. It should inspect the codebase when a fact is available there instead of asking the user to reconstruct it.

Use it when an idea is plausible but not settled. Good examples include:

• a new API contract
• a permission model
• a caching strategy
• a workflow redesign
• a schema change

The point is not to ask endless hypothetical questions. The point is to resolve the decisions that implementation would otherwise make accidentally.

Start with a concrete proposal. State the goal, constraints, existing artifacts, and desired output. Ask the agent to inspect relevant files first, then grill the plan one decision at a time. Keep a record of the resulting decisions, non-goals, open risks, and the next artifact to create.

AI Hero notes that Matt Pocock now generally recommends a broader domain-model workflow when coding plans need to be aligned with a project’s vocabulary, context files, and architecture records. grill-me remains valuable as a focused pressure-test when you want sharp questions rather than a complete modeling process.

Superpowers: turn decisions into a controlled delivery process

Once the direction is clear, Superpowers supplies the broader development workflow. Its repository describes a process where an agent clarifies the actual outcome, develops a specification and design, gets approval, creates an implementation plan, emphasizes true red/green TDD, and proceeds through implementation and review. It also supports subagent-driven development for work that has real task boundaries.

Use Superpowers for work where the cost of an incorrect assumption is meaningful:

• new features
• public API changes
• complex bugs
• behavioral refactors
• migrations
• security-sensitive changes

It is deliberately heavier than the process you need for a one-line typo.

The key benefit is the presence of gates. Clarification catches the wrong outcome. Design approval catches a poor shape. A plan makes sequencing visible. Red/green tests make selected behavior executable. Review compares the delivered diff with the approved intent rather than merely checking whether the code looks reasonable.

For a team-invitation feature, the workflow could establish expiry and revocation rules, define authorization boundaries, choose the token lifecycle, plan storage and migration, write failure-case tests, implement in small slices, and review the result against the original product behavior. Each step reduces the chance that a polished patch is solving an unowned problem.

Caveman: keep execution communication compact

Caveman changes an agent’s output style toward concise, direct language. Its README frames the goal as shrinking the agent’s “mouth,” not its “brain,” and says code, commands, and errors remain exact. The project claims 65% fewer output tokens; treat that as a project claim rather than a universal benchmark.

Caveman belongs after the important decisions have been made. It is excellent for a known-scope bug, a test failure, a terminal-heavy task, or a review follow-up.

Instead of several paragraphs of acknowledgement, ask for:

• root cause
• files changed
• validation run
• result
• remaining risk

Concise mode is not the right choice when nuance is itself part of the deliverable. Do not compress discovery, architecture, security analysis, incident communication, or onboarding into slogans. The rule is simple: reduce filler, never evidence.

A practical operating pattern is to work in normal detail until the design is approved, then switch to concise execution reports. Require the agent to remain explicit about blockers and assumptions. A short warning is useful; an omitted warning is not.

handoff: carry the live thread across a boundary

handoff creates a compact document that a fresh agent can use to resume work. It captures what is in flight, why it matters, what should happen next, and suggested skills for continuation. Crucially, it references existing specifications, plans, ADRs, issues, commits, and diffs rather than copying them.

It is saved to the operating system’s temporary directory, not the workspace, and is intended to redact secrets and personally identifiable information.

Use it before ending work, near a context limit, when moving a task between agents, or when deliberately resetting a conversation. Pass a note about the next session’s purpose so the handoff is tailored to the next action.

A good handoff names the objective, completed work, settled decisions, blockers, validation, canonical references, and one precise next action.

“Continue tomorrow” is not enough. “Service-layer authorization is complete; inspect the notification adapter before implementing email delivery; the approved spec is at this path; targeted tests pass” is actionable.

The integrated workflow

1. Frame the request. State desired outcome, constraints, and non-goals.
2. Use grill-me. Pressure-test linked decisions and inspect repository evidence.
3. Use Superpowers. Convert settled decisions into an approved design, plan, tests, implementation, and review.
4. Use Caveman during execution. Keep updates compact while preserving findings, commands, test results, and risks.
5. Use handoff at transitions. Preserve only the resumable thread and point to durable artifacts.

Not every task needs every stage. A trivial local change might use none of them. A medium feature may need Superpowers and Caveman. A risky design change may begin with grill-me and end with handoff. The value is in choosing the appropriate control, not in mechanically invoking every tool.

How to adopt the stack

Start small. Pick one feature with meaningful ambiguity. Ask the agent to inspect the relevant code and grill the proposal. Require a reviewable design and test plan. Once approved, switch to short execution reports. At the first planned context switch, create a handoff and ask a fresh agent to continue from it.

Measure outcomes that matter:

• how many assumptions were caught before code
• whether reviewers can explain why a diff exists
• how often agents repeat discovery after a switch
• whether concise reporting shortens the human review loop

Do not judge success only by token count or by how impressive a generated plan looks.

Limits and guardrails

These skills do not replace accountable engineering judgment. They cannot decide product strategy, guarantee secure systems, or prove that acceptance criteria reflect real user needs. They help make decisions, evidence, and transitions visible.

Use source control, reviews, tests, observability, and normal release controls. Keep secrets out of conversations and handoffs. Treat agent recommendations as inputs to a decision, not the decision itself.

Bottom line

Reliable AI-assisted development is not about making an agent behave the same way all the time. Ask it to question when the plan is uncertain, follow a disciplined workflow when the change is consequential, communicate briefly when execution is clear, and hand off cleanly when context changes.

Caveman, Superpowers, grill-me, and handoff each make one part of that system sharper.

Sources

• Caveman repository
• Superpowers repository
• AI Hero: grill-me
• AI Hero: handoff