Skip to main content
skill CX Codex

drill — Claude Code skill: what it does, how to install

A skill for Claude Code interviews the user about a plan or design until its decisions are settled. It runs for new features, unresolved designs, or a request to “drill this.”

MIT 1,000 installs ★ 10 updated 2026-10-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pwguler/skills --skill drill -a claude-code
Open on GitHub

What drill does

drill questions a plan or design and checks the answers against the project’s code and domain model. Before the interview, it reads code, docs, recent commits, CONTEXT.md files, and ADRs. If a request has an obvious solution, the skill states a one-sentence plan and moves straight to implementation.

For harder choices, it presents distinct approaches and their trade-offs, tests boundary cases, and separates independent parts of a request. The session ends only after the decisions are resolved and the user explicitly agrees; implementation starts afterward. For settled work, the skill writes a specification to docs/specs/<slug>.md. If questions remain, it creates a draft instead. The core-interview skill is needed for the interview.

What it helps with

  • stress-test a feature plan before implementation
  • settle open choices in a design
  • agree on the structure of a new codebase area
  • compare a user’s claims with the project code

Example prompts for the agent

  • Interview me about this plan until its decisions are settled.
  • Question this feature design before implementation begins.
  • Drill me on the structure of this new codebase area.

How to install drill

1Skills CLI (Vercel)

npx skills add pwguler/skills --skill drill -a claude-code

2Manually: put the files in place

~/.claude/skills/drill/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/drill/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about drill

How do I install drill in Claude Code?

Run npx skills add pwguler/skills --skill drill -a claude-code. The skill file is at ~/.claude/skills/drill/SKILL.md.

What does drill do?

It interviews the user about a plan or design, checks claims against the code, and helps settle decisions before implementation.

What does drill need to work?

The core-interview skill is needed for the interview. drill also reads the project code, docs, and recent commits before asking questions.

Source text

SKILL.md · MIT
---
name: drill
description: "Question a plan or design until every decision in it is settled and agreed. Read this skill first when the user asks for a new feature, or when a design is not settled. Use it when the user wants a plan stress-tested or a design settled before building. Use it also to settle the structure of a new codebase or area. Use it when the user says \"drill this\" or \"drill me\"."
---

Run the `core-interview` skill on the plan or design under discussion. The interview also tests the plan against the domain model of the project.

Fast path: when a settled spec in `docs/specs/` already covers the request, go directly to `implement`. Otherwise, first sharpen the request silently. Ask how a top expert would approach it: the sources, the methods, and an outside check that proves the result. An outside check is evidence from outside the work: a test runner, a live system, or an independent source. Ask what the user really wants, and whether the request says too much or too little. Drop constraints that do not serve that goal. Add only what improves the result, and do not make the work larger. Leave open each choice that belongs to the user. Do not show the user a reworded request, except the one-sentence plan below. Then find the size of the request. A request with no real decision tree is obvious. Examples are one obvious change, a small diff, or a criterion that one sentence can state. Say that the request is obvious, and go directly to `implement` with that sentence as the plan. The sentence keeps the outside check as its criterion. Do not write a spec for an obvious change. The fast path still tests its sentence: state the sentence, then test it. If you cannot state the sentence, or the sentence shows a decision to make, the request was not obvious. Then run the interview.

1. Before the first question, read the project context: code, docs, and recent commits.
2. Before the first question, look for `CONTEXT.md` at the root. Look also for `CONTEXT-MAP.md` and each `CONTEXT.md` that it lists. Look for ADRs under `docs/adr/`, also for ADRs that apply to one context only.
3. On a nontrivial codebase with no `CONTEXT.md`, offer to collect candidate terms from the code and the docs. Put each term to the user during the interview. A term goes into the glossary only after the user confirms it.
4. If the request holds several independent parts, say so. Drill the first part, and keep the other parts for later.
5. Before you choose a direction, show 2 or 3 different approaches with their trade-offs, not variations of one approach. Put your recommendation first, as [exhaust the design space](references/exhaust-the-design-space.md) says. When a new requirement comes into an existing design, one approach is the [redesign from first principles](references/redesign-from-first-principles.md). Check each architectural shape against the [design red flags](references/design-red-flags.md). Some decisions depend on look, feel, or flow that text cannot settle. For these, run the `prototype` skill to build a throwaway that the user reacts to. Discard it when the user picks the direction.
6. The session ends when every branch of the decision tree is resolved. Then state the settled design in a short summary. Get the explicit agreement of the user before any implementation starts.
7. When the settled design is implementation work, write the spec to `docs/specs/<slug>.md` in the target project. Use [spec-format.md](references/spec-format.md): goal, non-goals, checkable acceptance criteria, verification commands, and phases for a phased migration. Put the outside check from the fast path into the verification commands.
8. Sometimes this session cannot resolve the decision tree. Decisions can wait for research outside this context, or the tree can be too large for one session. Then do not write a settled spec for a design that is not settled. Write the spec as a **draft**: [draft-spec.md](references/draft-spec.md).

Rules:

- Remove from the design everything that the stated constraints do not demand. Check what stays against [experience first](references/experience-first.md). Read it when a trade-off on product scope, UX, or an interface puts ease of building against the consumer's experience.
- Create a file only when it has content. Create `CONTEXT.md` with the first settled term, and `docs/adr/` with the first ADR.
- In the interview, **hold the user to the glossary.** When the user gives a word a meaning that is different from `CONTEXT.md`, say so at once. For example: "The glossary says a Refund is X. You seem to mean Y. Which is it?"
- In the interview, **replace vague words.** For a vague word or a word with many meanings, offer an exact term. For example: "By 'user', do you mean the Account holder or the Operator? They are different."
- In the interview, **test with cases.** Where two concepts meet, pick a concrete case at the border between them. Ask what happens.
- In the interview, **check claims against the code.** When the user says how something works, look at the code. Name each difference. For example: "The code refunds whole Payments. You described partial refunds. Which is true?"
- In the interview, **write terms when they settle.** Update `CONTEXT.md` when a term is settled, not at the end. It is only a glossary: no plans, notes, or implementation choices. Use the format in [terms.md](references/terms.md).
- In the interview, **keep ADRs rare.** Offer an ADR only for a decision that passes the three tests in [decision-record.md](references/decision-record.md). The decision is costly to undo, puzzling from the code, and won against a real alternative.
- **Later sessions work on the draft.** When a session opens a spec that still has an `## Open decisions` section, follow [draft-spec.md](references/draft-spec.md).

© pwguler · MIT · pwguler/skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set15

The whole set →
research The research Claude Code skill traces library and API behavior to primary sources, or investigates why code took its current shape. It activates for lookups and questions about the history of a setting or constant. CX Codex +1 1,000installs debug debug is a Claude Code and Cursor skill that traces bug root causes step by step and verifies regression tests. CX Codex +1 1,000installs verify verify — a skill for Claude Code checks claims about completed or fixed work against fresh command output. It runs before a commit or PR, after changes, and before reporting that work is done or tested. CX Codex +1 1,000installs land land is a Claude Code skill that finishes a development branch through merge, PR, keep, or discard. It runs after implementation is complete. CX Codex +1 1,000installs implement implement — a skill for Claude Code and Codex that executes settled plans in thin test-driven slices. Runs when prompted to build code from a spec or slice plan. CX Codex +1 1,000installs rubric rubric — a skill for Claude Code finds defects in changes and judges design, interface, or writing quality. It sets evaluation criteria before asking an independent subagent to inspect the work. CX Codex +1 980installs prototype This Claude Code skill builds visual UI prototypes before implementation begins. It activates for mockup requests and helps settle a look or flow that text cannot resolve. CX Codex +1 978installs tldr tldr — a skill for Claude Code and Codex that reports completed tasks as concise outcomes instead of tool transcripts. Triggers after builds, verification runs, file changes, or catch-up queries. CX Codex +1 977installs

Project sponsors

Companies that keep this analytics open