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, or 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, migr