decisionnerd/dev-skills

recon

Scout the current work and recommend the next skill or action.

View source

How to use

  1. Copy the installation command and review the source package before installing it in your own agent environment.
  2. Check the source document for required tools, credentials and supported hosts.
  3. Describe your input and desired deliverable; review the output against the source material.
npx skills add https://github.com/decisionnerd/dev-skills --skill recon

Before you start

  • Installation does not include a model subscription, API allowance or permission to access your files.
  • Repository stars and installation counts describe activity, not an independent quality or security test.
Original skill document

Rendered from the source repository. Headings, examples, code, tables, links, and referenced images are preserved.

Recon

Situational awareness for the current repo. Recon gathers evidence, sets scope, and recommends the next skill from this pack. It does not silently implement, open PRs, or mutate GitHub unless the requested scope or a completion chain (including an issues #N handoff) calls for it.

If the user is lost (“idk”, no sense of purpose, need coaching across DocSlime / ProductFeeling / Impeccable / vendored skills), prefer idk-now instead of this skill.

Operating contract

Shared by every DecisionNerd/dev-skills skill. Canonical copy: handbook/concepts/14-operating-contract.md.

  • Define done first. Before using tools, write the finish line in one or two lines: acceptance criteria (existing issue AC, BDD scenarios, tests, or contract; otherwise propose them and where they should live) and the evidence that will prove them. Re-check it before reporting done. Never report done on unverified work.
  • Requested scope sets the finish line. A question ("is it ready?", "why is it broken?", "what next?") ends with the answer and a Next: line naming the exact next invoke. An outcome request ("fix", "finish", "land", "#42") continues through the chain (diagnose → fix → test → check-readiness → merge-it) until the outcome or a real blocker. Do not end a turn with "Do you want me to…?" for in-scope, in-repo work.
  • Stop only for real blockers. Stop and ask only when you cannot continue without the user, or before: deleting data or unmerged work, force-push or history rewrite, changing anything outside this repository (GitHub objects, deployments, live data, production or paid resources, external services), or leaving the requested scope, unless the user's request already named that exact action. Keep the harness's permission prompts for risky commands. Otherwise keep going and put status notes in the same message as the next action.
  • Ask well, once. For a genuine question use the harness's structured question tool when it has one (Claude Code: AskUserQuestion; Codex: request_user_input when the current mode supports it; T3 Code: the question tool) with concrete options; otherwise plain text with numbered options. Treat the answer as settled; do not re-open earlier verdicts, plans, or answers unless asked.
  • Fan out when work is parallel. Use subagents for independent reads (repo survey, evidence gathering, per-option research, per-area audits) and independent verification (a reviewer that did not write the change). Writes stay single-owner per path set and sequential. Brief every child with goal, done-when, constraints, must-not, and return shape; verify each result before consolidating. Use Claude Code's Workflow tool only when orchestrating many subagents truly needs it; it is expensive. T3 Code: its delegated subagents — with optional worktree isolation for independent verification — cover this without the Workflow tool.
  • Pick the model tier per child; defer to routing config. If the harness or user config already routes subagents, follow it and do not pass a model. Otherwise pick a tier per child: mechanical search or inventory → fast/cheap; implementation and evidence gathering → mid; planning, review, adversarial verification → top. Tier names differ per harness (Claude Code: haiku / sonnet / opus or fable; T3 Code: inherit by default or pick from its live provider/model catalog). Set the choice with the harness's spawn model param or agent frontmatter model: (per-harness details: skills/agents/references/sub.md). Where the harness cannot choose, children inherit or the harness picks; say which in the status note.
  • Keep a checklist on long runs. For more than about five steps or work that crosses skills, keep TASKS.md at the repo root and tick items as they finish. Do not commit it unless the repo already tracks one.
  • Close every run with three headings. Blocked on me (the one genuine question or blocker, else "none"); Changed (files, commits, GitHub objects, deploys, else "nothing"); Found (evidence, verdict, and Next: <exact invoke>).

Commands

CommandScopePrimary output
(none)Infer from git logs + branch/worktreeScope summary + ranked next-skill suggestions
repoWhole repositoryHealth/readiness recon + next skills
issue / #NOne GitHub issueImplementation-ready plan (see references/issue.md)
milestoneOne milestoneProgress, gaps, issue set + next skills
help / library—Command + skill map

Routing:

  1. No args → git-log default (below).
  2. First word repo | issue | milestone | help → that command; remainder is the target.
  3. Bare #123 / 123 / issue URL → issue.
  4. Clear intent (“recon the launch milestone”, “scout the repo”) → map and run.

Default (no argument): git logs set scope

Run this sequence first (read-only):

bash
git status --short --branch
git branch --show-current
git log --oneline -20
git log --oneline --decorate -10 --all
git diff --stat HEAD
git diff --stat main...HEAD 2>/dev/null || git diff --stat master...HEAD 2>/dev/null

Also when useful: gh pr view --json number,url,title,state,baseRefName,headRefName for the current branch; parse issue numbers from branch name / recent commit messages (#123, Fixes #123).

When gh is available, fan out git, GitHub, and docs surveys to parallel read-only subagents (fast tier) and consolidate in the parent before stating the situation.

From that evidence, state:

  1. Scope — branch, ahead/behind, dirty files, recent themes from commits, linked issue/PR if any.
  2. Situation — one short paragraph (shipping? stuck? dirty WIP? main with no feature branch?).
  3. Next — ranked suggestions using the skill map (below), each with a one-line why and an exact invoke hint (e.g. issues critique #42, pulls status, merge-it).

Do not ask the user to restate what git already shows unless something is ambiguous (multiple issues, wrong repo).

repo

Whole-repo recon (read-only):

  • Default branch, open PR count, open issue pressure, milestone list (gh when available).
  • AGENTS.md / CI / obvious docs gaps.
  • Recent git log themes and risk areas.
  • Fan out git, GitHub, and docs surveys to parallel read-only subagents (fast tier) when gh is available; consolidate in the parent.
  • Suggest: issues create, milestones plan|status, troubleshoot-app / diagnose-bug if logs imply breakage, pulls / merge-it if work is stranded on branches or release-shaped per repo policy.

Details: references/repo.md.

issue

Deep issue recon / implementation plan. Follow references/issue.md and references/planning-checklist.md.

Planning does not require native Plan Mode. Use read-only inspection in the current agent when a mode switch is unavailable, and respect any active host restrictions. A standalone planning request stops at the plan; when the request was an outcome or came from a completion workflow such as issues #N, return the plan and continue that workflow once the host permits execution. Before implementation, follow workspace ownership. If issues is not installed, use a dedicated task worktree with verified exclusive ownership, preserve the shared checkout, and carry the verified absolute path, branch, base revision, and ownership through every execution handoff and implementation result.

End with the three closing headings; Found ends with Next: <primary invoke> as a statement.

milestone

Milestone recon. Follow references/milestone.md. Summarize purpose, due date, open/closed counts, blockers; suggest milestones narrow|plan|critique|close, issues for gaps, merge-it (Stage/Ship phases) when release-shaped.

Skill map (DecisionNerd/dev-skills)

Use this map when recommending next steps. Prefer the smallest next skill that unblocks the user.

SituationSuggest
Lost / idk / need vision-tied next stepidk-now (considers DocSlime, ProductFeeling, Impeccable, vendored)
Goals/process/system/plan feel overcomplicated`kiss audit\goals\process\system\plan\flow`
Repo split/combine/monorepo/CI/secrets (ESC)`repos status\split\combine\monorepo\ci\secrets`
Need a new / better issue`issues create\critique\refine\narrow\widen\document`
Organize release/version work`milestones status\plan\critique\narrow`
Open or improve a PR`pulls create\critique\status\refine\explain`
Autofix → CI green → merge → close issuemerge-it
Is the issue done enough to PR/close?check-readiness
Live UI / data-plane brokentroubleshoot-app (diagnoses and fixes in-repo)
Backend / algo / API bugdiagnose-bug (diagnoses and fixes in-repo)
Agent / LLM quality or thrashagents slap / agents analyze (+ Langfuse via observe-it)
Plan a repair from diagnosisfix-it
Need tests / coverage / BDD evidencetest-it (name regime A/B/C first)
Need logs/metrics/traces/analyticsobserve-it (regime-matched; Langfuse for C)
Need repo docs / runbooks (surgical)document-it — DocSlime only when altitude earned
Need options/tradeoffs before buildingresearch-it
Need structure cleanup without behavior changerefactor-it
Architecture bet needed before buildingarchitect-it
Agent thrashing / dumb workflow / need drainagents slap
Design / analyze / optimize agents or use subagents`agents design\analyze\optimize\sub`
Dangling worktrees / build junk / caches / stale branches`tidy-up scan\workspaces\artifacts\caches\deep`
Staging land / production promote (repo policy)merge-it (Stage / Ship phases)
Unsure / no argthis skill’s default git-log recon

When suggesting, name the skill and a concrete command string the user (or you) can run next. One primary recommendation, then 2–3 alternates.

Output shape (default / repo / milestone)

markdown
**Scope**
- Branch: ...
- Recent work: ...
- Linked: issue/PR/milestone or none

**Situation**
<1 short paragraph>

**Recommend**
1. **Primary:** `<skill> <command> …` — <why>
2. Alternatives: ...

**Blocked on me**
<The one genuine question or blocker, else "none">

**Changed**
<Files, commits, GitHub objects touched, else "nothing">

**Found**
<Situation summary and `Next: <primary invoke>`>

For issue, use the plan format in references/issue.md instead, ending with the three closing headings where Found ends with Next: <primary invoke>.

Grounding

This skill’s TTPs are grounded in current engineering baselines (DORA, GitHub Docs, Fowler/Beck, Google SRE & SWE book, OpenTelemetry, OWASP LLM / NIST AI RMF, Diátaxis — see handbook sources.md).

Situational awareness before action (SRE incident habit): read git/issue/PR state, then the smallest next move. For one issue, plan a reviewable small CL (Google eng practices).

Handbook card: handbook/practices/recon.md.

from this repository

More skills

All skills
decisionnerd
Community

agents

Work agent systems with command arguments: slap (emergency-fix stupid agent behavior and safely drain dumb workflows), analyze, optimize, design, and sub / sub-agents (delegate via subagents). Use when the user says agents, /agents , agent loops are thrashing, workflows need draining, or they want agent architecture, analysis, or parallel subagent execution.

1h installs
3
GitHub stars
0
Updated
Nov 4
decisionnerd
Community

architect-it

Design or evolve the architecture of a system, module, or feature — survey the codebase, frame the bet (boundaries, placement, data flow), propose options with tradeoffs, record the decision where the repo keeps decisions, and plan the first slice. Use when the user says "architect it", asks to design a system or module, review architecture, plan boundaries before building, or untangle a structural bet that refactoring alone cannot fix. Not for behavior-preserving mechanics (use refactor-it), co

1h installs
3
GitHub stars
0
Updated
Nov 4
decisionnerd
Community

check-readiness

Review whether a GitHub issue is complete enough for its current stage and decide the next PR or closure action. Use before PR, before closing an issue, after merge, or when auditing a closed issue for regressions or missing scope. For pre-PR checks, use CodeRabbit CLI review; when an open PR exists and corrective review work is needed, use autofix.

1h installs
3
GitHub stars
0
Updated
Nov 4
decisionnerd
Community

council

Convene independent reviews from three model providers and reconcile their findings. Use when the user says council, asks for a multi-model review, or wants several providers to challenge a plan or implementation.

1h installs
3
GitHub stars
0
Updated
Nov 4