--- name: technical-recon description: "Technical recon of an already-groomed, stakeholder-accepted issue that the dev team has not yet vetted or sized — dispatch a read-only sub-agent (one per issue, in parallel for a batch) to trace the ask into the codebase, produce a verified implementation approach, assert a level-of-effort (LoE) estimate with confidence, surface risks/unknowns/dependencies, recommend a split when the work is too big for one PR, and pin the eventual dispatch model/effort/lane — then post the findings to the issue and move it to a dev-vetted state. Use whenever an engineering or project lead hands you one or more issue numbers/keys to 'recon', 'scope', 'size', 'estimate', 'tech-review', or 'assess implementation' before any code is written; also use when deciding whether a groomed issue is actually ready for a dev dispatch. This is the deeper dev-side pass, distinct from the cheap intake-triage recon in the issue-filing skill." --- # Technical Recon: scope, size, and de-risk a groomed issue before dispatch An issue can be fully groomed and accepted by stakeholders — clear symptom, desired behaviour, acceptance criteria — and still be unsafe to dispatch, because nobody on the dev team has confirmed *how* it would be built, how big it is, or what it might break. Technical recon closes that gap: a read-only sub-agent traces the ask into the actual codebase and returns an implementation approach, a level-of-effort estimate, the risks, and a dispatch recommendation. The issue moves from "stakeholders want this" to "the dev team knows what this costs and how to build it." This is **not** the intake-triage recon in the issue-filing skill (gh-issue-filing / jira-issue-filing). That one runs a cheap model to classify *stub* issues into ready-to-dispatch / needs-spec-input / blocked by a five-rule decision tree, with a capped blast radius. Technical recon is the opposite end: the issue is already groomed, and the question is the engineering answer — design, cost, risk — which needs a capable model reading real code, not a cheap classifier. The two compose: intake-triage decides an issue is *specified*; technical recon decides it is *buildable* and *sized*. Compose with the siblings: dispatch the recon agents with the dispatching-subagents skill; read the issue and post findings with the issue-filing skill's anatomy conventions; set the resulting labels/fields with the control-field skill (gh-issue-labels for GitHub, jira-issue-fields for Jira); and when recon clears an issue, the orchestrating-slots loop dispatches the implementation per the issue-locking skill (gh-issue-locking / jira-issue-locking). Recon itself never claims, never writes code, never opens a PR. ## Project bindings Define these in the adopting project's CLAUDE.md; the body refers to them by placeholder. | Binding | Meaning | Example | |---|---|---| | `` | The LoE vocabulary the team estimates in | T-shirt `XS\|S\|M\|L\|XL` (below) | | `` | Model tier for recon — a capable one, never the cheap tier | `sonnet` (escalate to `opus` for deep/cross-cutting asks) | | `` | The label/status meaning "dev-vetted, ready to dispatch" | `ready-to-dispatch` | | `` | "a technical decision must be made before build" | `needs-spec-input` | | `` | "a dependency must land first" | `blocked` | | `` | Where the size is recorded | a `loe:` label, or the Jira Story-points / a custom field | | `` | Contention-prone files that mark the plumbing lane (see the issue-filing skill) | DB schema, API schema, shared types, design tokens, root manifest/lockfile | Default `` (override per project): **XS** ≈ <½ day, trivial/local; **S** ≈ ~1 day, one surface; **M** ≈ 2–3 days, a few surfaces; **L** ≈ ~1 week, multi-surface or migration; **XL** > 1 week → **must be split** (recon proposes the split rather than sizing it whole). ## The recon is read-only — the sandbox A recon agent investigates and reports; it changes no code and no work-tracking state beyond its own findings on the one issue it was given. Allowed: - Read any repo file; `git grep`, `git log`, read the dependency graph and tests. - Read the issue and its comments (`gh issue view` / `getJiraIssue`) — including its own prior recon questions and the lead's answers, on a rerun. - Use the interactive ask-question tool, if the run provides one, to clarify direction with the lead (see the next section). - Post the findings as ONE comment; when asking, post one emoji-answerable comment per open question (see below). On a rerun, read the reactions on your prior question comments. - Set the LoE field and the verdict label/status on that issue (per the control-field skill). Forbidden — on attempting any, stop and emit `TECH-RECON-ERROR: `: - Edit or write any repo file; open a branch or PR. - Claim/assign the issue or set the active-lock marker — claiming is dispatch-time, owned by the orchestrator (see the issue-locking skill). Recon that self-assigns forges a claim other operators honour. - Mutate any other issue, or any PR. ## Reach ≥90% on direction before you size A groomed issue says *what* stakeholders want; it rarely pins *how* they want it built when the codebase offers more than one defensible path, and the wrong path is a wrong estimate. So: **investigate first, then — for any ambiguity that materially changes the approach, scope, or LoE — get the lead's direction until you are ≥90% confident you are sizing the thing they actually want.** Investigating before asking is what makes the questions worth asking: each one is concrete and code-grounded, with options drawn from what the code actually allows — never a lazy open-ended "how should I build this?". Below 90%, ask; do not size. Two channels, in priority order: 1. **Interactive ask-question tool, if the run has one.** Ask multiple-choice questions — each with a recommended option first and a write-in escape — looping until ≥90%. Then proceed in the same run to the full findings and verdict. 2. **No question tool available** — the usual case for a fanned-out sub-agent, which runs non-interactively. Ask through **emoji-answerable comments** so the lead replies in one click, no typing: - **One comment per question.** Reactions on a single comment can't disambiguate multiple questions, so each open question (or each proposed direction to confirm) gets its own comment. Quote the ambiguous part, then list each option on its own line tagged with the distinct reaction emoji the lead clicks to choose it; for a yes/no, use 👍 confirm / 👎 deny on the proposed-direction comment. - **Stay within the tracker's reaction set.** GitHub allows only eight reactions — 👍 👎 😄 🎉 😕 ❤️ 🚀 👀 — so map options onto those (e.g. 👍 = option A, 🎉 = B, 🚀 = C, 👀 = "none, see my reply") and never use number/letter emoji there; Jira's set is wider, but keep the mapping explicit either way. - **End every question comment with a one-line legend** stating exactly which emoji does what — e.g. `↩ React: 👍 keep current auth · 🎉 switch to sessions · 🚀 do both · 👀 none (reply below)`. The legend is mandatory; an un-legended emoji prompt is a guessing game. - Set `` and **STOP — do not guess an LoE.** On rerun, recover the answers from each question comment's **reactions** (plus any written reply — a written reply always overrides a reaction), then continue. One question, one comment, shaped like this: ```markdown **Recon — 1 decision needed before I can size this:** The issue says: > Which direction do you want? - 👍