# Grill skill

Point your coding agent at an idea, and walk out with a deployed application. The grill skill questions every decision in rounds, researches the market and the stack in parallel, and keeps going until the app is live in production. A plan or a prototype does not count as done.

## Use it in your agent

The grill skill reuses this site's references, so the code it writes follows the patterns its planning cites. Set up the prerequisites first, in order: the [MCP server](https://aipatterns.dev/agents), the [skills](https://aipatterns.dev/skills), and the [AGENTS.md](https://aipatterns.dev/agents-md).

Then add the `grill-skill` folder to your agent's skills directory - Claude Code keeps personal skills in `~/.claude/skills/` - and open a session with a kickoff prompt:

```text
I have an idea for an app: <describe it in one line>.
Load the grill skill and grill me.
```

The agent opens by setting expectations: the process takes time, and the goal is a production application. Then the grill starts. Each round brings numbered questions, each with a recommended answer:

```markdown
❓ Q1 - **Target users**: Who uses the product, and what do they do today without it?

➡️ Recommended: solo developers who track decisions in ad-hoc notes today.

---

❓ Q2 - **Version 1 scope**: Which single problem does version 1 solve?

➡️ Recommended: capture and search decisions only; sharing waits for v2.
```

Answer in shorthand - `1: yes, 2: backend instead`. The agent recomputes the open questions from your answers and asks the next round. It pauses for your approval before committing to an architecture and an implementation plan, and it never stops at a plan: the same session builds, tests, and deploys.

## How it runs

1. **Discover.** The agent orients in your repository, then grills the product vision, users, features, constraints, success criteria, and budget in short question rounds. While you answer, sub-agents research competing products, design references, and the candidate stack against official documentation.
2. **Plan.** Requirements get validated for gaps and contradictions. Architecture and technology choices come with trade-offs and a cost estimate checked against your budget. The design direction, implementation plan, testing strategy, and deployment plan follow - every document written to `docs/planning/`.
3. **Build.** Implementation runs milestone by milestone with tests green between them, reusing installed skills, MCP servers, and existing code. A security review closes the loop.
4. **Ship.** Deploy, verify production readiness - monitoring, backups, rollback - and hand over maintenance notes. The workflow ends at a verified deployment, not at a plan.

## What you get

Every run writes its decisions down, and keeps the documents in sync as answers change:

- Project brief and requirements specification
- Research report and reference collection
- Proposed architecture and technology rationale
- Design direction
- Implementation plan, testing strategy, and deployment plan
- Cost estimate, checked against your budget