Skip to main content
skill CX Codex

First 10 Moves — Claude Code skill: what it does and how to install

First 10 Moves — a Claude Code skill for exploring an unfamiliar repository before changing code. It starts when a task involves tracing a bug, locating a module, or finding a place to begin.

MIT ★ 26 updated 2026-11-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add wrg32786/aigent-os --skill first-10-moves -a claude-code
Open on GitHub

What First 10 Moves does

First 10 Moves gives the agent a reading sequence before it edits code. It starts with the request and project layout, then checks the manifest and README, searches for relevant terms, and follows the likely module from its exports to a caller. The agent reads one upstream call site before examining the function tied to the reported symptom.

Next, it checks relevant data or logs and tests a hypothesis with a focused read or query. It avoids running the code or attempting a fix before that check. At the end of the investigation, it reports the module path, entry point, hypothesis, evidence, and a minimal change plan. If the evidence does not support the hypothesis, it returns to the function with a revised one.

What it helps with

  • locate the module behind a bug
  • trace callers of a function
  • map an unfamiliar repository
  • test a hypothesis before editing code

Example prompts for the agent

  • Explore this unfamiliar repository and find where the headline generator is defined.
  • Trace this bug from its entry point to the function that triggers it.
  • Find out why headlines repeat and test a hypothesis before changing anything.

How to install First 10 Moves

1Skills CLI (Vercel)

npx skills add wrg32786/aigent-os --skill first-10-moves -a claude-code

2Manually: put the files in place

~/.claude/skills/first-10-moves/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/first-10-moves/

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

Questions about First 10 Moves

How do I install First 10 Moves in Claude Code?

Run npx skills add wrg32786/aigent-os --skill first-10-moves -a claude-code. The skill file is at ~/.claude/skills/first-10-moves/SKILL.md.

What does First 10 Moves do?

It guides an agent through an investigation of unfamiliar code, from mapping the project and locating relevant files to checking a hypothesis. Before editing, the agent reports its evidence and a minimal change plan.

When does First 10 Moves activate?

It is intended for tasks involving an unfamiliar codebase, a bug investigation, or locating and understanding a function. The agent waits until the investigation is complete before writing a fix.

Source text

SKILL.md · MIT
---
name: First 10 Moves
description: "Read and explore unfamiliar code before asking questions. Use when new to a repo, orienting in an unfamiliar codebase, or finding where to start."
---

# First 10 Moves

When dropped into an unfamiliar codebase or asked to fix something in code you don't know — run this sequence before doing anything else. The principle: **most "clarification" questions are answered by 5 minutes in the relevant file.** If the answer is in the code, the docs, or the file tree — find it there before asking.

## When to use

- Fresh in an unfamiliar codebase
- Asked to fix or change code in an area you haven't worked in
- Tempted to ask "where does X live?" or "how does Y work?"
- Use on prompts like: "fix the X", "investigate", "trace this bug", "how does X work", "unfamiliar codebase", "where is X defined", "what calls Y", "navigate the code", "find the bug in"

## The sequence (run top-to-bottom)

### 1. Re-read the user's request
Look for clues. "Fix" implies a bug. "The headline generator" implies a named module. Note any screenshots, errors, or examples included. **The exact phrasing embeds most of the diagnosis** — don't abstract it away.

### 2. Get the lay of the land (~30 seconds)
- List project root
- Identify main source directory
- Read `package.json` / `pyproject.toml` / `Cargo.toml` (whatever the manifest is)
- Read README if short

This rules out a lot. You learn the language, framework, build system, and entry point in 30 seconds.

### 3. Search for the keyword across the project
One ripgrep, filtered to relevant extensions. The matches will cluster around the real module.

### 4. Pick the most likely 2-3 matched files
**Filenames are huge signal.** `aiHeadlineGenerator.ts` beats `headlineUtils.test.ts`. Production code beats test code. Implementation beats type definitions.

### 5. Read the public surface of the top candidate
**Imports + exports, not bodies.** Shape first. What does this module take in and put out? What does it depend on?

### 6. Find the entry point — who calls this?
Search for the main exported function name. Call sites tell you how the module fits into the larger pipeline.

### 7. Read one upstream call site fully
Concrete example of "what inputs does this receive in real use?" That constrains everything downstream. Don't read 5 call sites — one is usually enough.

### 8. Read the main function body, focused on the symptom
- **Specific symptom** ("headlines are repeating") → find the path that produces it (the loop, the dedup logic, the source list)
- **General "fix it"** → top-to-bottom, alert for obvious issues (off-by-one, null guards, stale comparators, hardcoded values)

### 9. Query the data the function works with
A few DB rows, the actual config file, the recent log lines. **Reality often disagrees with code's assumptions.** This catches it fast.

### 10. Form a hypothesis, verify with one targeted read or query
"I think X because Y, confirm by checking Z."
- Confirmed → fix.
- Not confirmed → loop back to step 8 with the new hypothesis.

**Hit rate at step 10: ~80% land a correct hypothesis.** The remaining 20% loop back with what was learned.

## What NOT to do in the first 10 moves

- ❌ Read every file in the directory
- ❌ Read tests before reading the code under test
- ❌ Ask a clarifying question (unless genuinely too vague)
- ❌ Start writing fix code (first fix attempt comes AFTER move 10)
- ❌ Run the code to "see what happens" — understand it statically first
- ❌ Open the IDE outline / class hierarchy explorer — too noisy
- ❌ Ask the user "where is X defined?" — grep is faster than asking

## Most of the work is reading, not writing

A typical non-trivial change is **~80% reading, 20% writing.** The edit is the *result* of the engineering, not the engineering itself. Agents that flip this ratio produce code that doesn't fit the surrounding system.

## Output format

When you complete the recon, before writing any fix code, output:

```
**Recon complete:**
- Module: {path/to/file.ts}
- Entry point: {function name + caller path}
- Hypothesis: {what I think is wrong, in plain English}
- Verified by: {what I read/queried that confirms the hypothesis}
- Plan: {smallest change that solves it}
```

Then execute the fix.

© wrg32786 · MIT · wrg32786/aigent-os

Similar skills

All skills for Agent setup: memory, context, orchestration →
repo-skillopt objectivlabs repo-skillopt — a Claude Code skill that maps a repository and builds a specification grounded in files, configs, and tests. It activates for requests to explain, document, change, or assess a codebase. CX Codex +1 598installs ai-bug-triage kindlmann ai-bug-triage builds a hybrid bug triage pipeline: normalizes CI logs, deduplicates failures via deterministic fingerprints, and uses an LLM to evaluate severity and draft tickets. CX Codex +1 1,700installs bmad-investigate aj-geddes The bmad-investigate Claude Code skill investigates bugs and turns findings into a case file. Invoke it to trace a reported failure, update an open investigation, or check a draft before handoff. CX Codex +1 102installs btca-local davis7dotsh The btca-local skill guides an agent through searching Git repositories on your machine and citing the code it finds. Use it to investigate a project’s source. CX Codex +1 1,000installs principle-redesign-from-first-principles backnotprop principle-redesign-from-first-principles — a skill that makes the agent rebuild an existing design as if the new requirement had been there from day one. Use it when a change ripples through types, docs, and examples. CX Codex +1 10,200installs thinking-first-principles tjboudreaux thinking-first-principles — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that separates real constraints from inherited convention and rebuilds from primitives. CX Codex +1 844installs

From the same set58

The whole set →
impeccable The impeccable Claude Code skill guides frontend design, helps establish a project’s visual direction, and can extract components and design tokens. It needs context about users, their tasks, and the brand’s tone. CX Codex +1 ★ 26repo stars humanize-docs humanize-docs is a Claude Code skill that transforms robotic documentation into natural prose. It rewrites technical docs and README files by removing repetitive checklists and rigid section structures. CX Codex +1 ★ 26repo stars Honesty Check The Honesty Check Claude Code skill builds an honesty ledger for completed work. It runs before an agent reports a task as done or prepares it for review. CX Codex +1 ★ 26repo stars first-win This Claude Code skill offers three starter tasks that end with a usable artifact. Run /first-win to turn a post into social content, shape an idea into a plan, or sort email into priorities. CX Codex +1 ★ 26repo stars find-weakness find-weakness — a skill for Claude Code and Codex isolates the single strongest objection and the riskiest unstated assumption in any architectural choice or claim. CX Codex +1 ★ 26repo stars Envelope The Envelope Claude Code skill sorts requests into three actions: proceed, ask one question, or propose a plan first. It activates when an agent must decide whether to act or pause for clarification. CX Codex +1 ★ 26repo stars dream The dream Claude Code skill synthesizes session evidence into lessons and proposed changes. Run it to review recent sessions, consolidate notes, or spot recurring patterns. CX Codex +1 ★ 26repo stars digest The digest Claude Code skill reviews staged entries in MEMORY_CANDIDATES.md. It presents choices for each one: promote it, skip it, or replace an existing entry. CX Codex +1 ★ 26repo stars

Project sponsors

Companies that keep this analytics open