Reconnaissance logo

Reconnaissance

Community
kucherenko
reconnaissance

Use when beginning a new heist — deploys associates to survey the target codebase, existing tests, dependencies, documentation, and the ledger to produce a reconnaissance dossier for the don's review

Overview

Publisherkucherenko
Repositorygangsta
Skill namereconnaissance
Stars
86
Forks
10
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by kucherenko on GitHub. Read the source before you install it.

Installation

Install the Reconnaissance AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/kucherenko/gangsta/tree/master/skills/reconnaissance
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/kucherenko/gangsta.git /tmp/gangsta
mkdir -p .claude/skills
cp -r /tmp/gangsta/skills/reconnaissance .claude/skills/reconnaissance
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Reconnaissance in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Reconnaissance on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Reconnaissance is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Reconnaissance: Intel and Environment Mapping

Overview

Every Heist begins with gathering intel. The Underboss deploys Associates to perform a detailed survey of the target codebase and infrastructure. The output is a Reconnaissance Dossier that informs all subsequent phases.

Trigger

Invoked when the Don expresses building or creative intent.

Process

Step 1: Analyze Intent

The Underboss parses the Don's request to identify:

  • Objective: What is being built or changed?
  • Scope: Which parts of the system are affected?
  • Constraints: Any explicit requirements or limitations?

Step 2: Deploy Associates

Dispatch Associate subagents in parallel to gather intel.

Subagent type: Use subagent_type: "associate" for all Associate dispatches. Do NOT use "general" or "general-purpose" — these are not valid in a Gangsta installation.

Greenfield Mode (empty or near-empty workspace)

Before dispatching the standard survey, count the files in the working directory (excluding .git, docs/gangsta/, and other meta directories).

Trigger: the workspace contains fewer than 5 source files OR no recognizable project manifest (package.json, requirements.txt, go.mod, Cargo.toml, pyproject.toml, etc.).

When the trigger fires, the reconnaissance objective shifts from "survey the existing code" to "sharpen the IDEA". The standard codebase survey is still run (to capture what little exists), but it is no longer the center. Instead, deploy these associates in parallel:

Associate TaskWhat to Investigate
Idea FramingRestate the Don's objective in the Don's own words. Identify the problem being solved, who has it, and what evidence (if any) the Don offered. Surface hidden assumptions.
AnaloguesSearch the internet for existing tools, libraries, products, or papers that solve the same or adjacent problems. For each analogue: name, what it does, what it gets right, what it gets wrong, license/hosting model. Use the webfetch tool. Produce at least 3 analogues; if fewer than 3 exist, say so and explain why the space is sparse.
Prior Art & PatternsSearch the internet for relevant prior art: protocols, data formats, algorithms, design patterns, prior attempts, postmortems. Cite sources (URLs).
Constraint & Risk SurveyEnumerate known constraints for the domain: performance ceilings, security concerns, regulatory, accessibility, platform limits. Cite sources.
Codebase Structure(Standard survey — what little exists in the workspace.)
Ledger Search(Standard survey.)
Constitution(Standard survey.)

The Dossier's Codebase Overview section becomes a thin note describing the empty/near-empty state. The bulk of the Dossier moves to new sections — see the Greenfield Dossier Format below.

Greenfield Dossier Format (replaces the standard format when greenfield mode fires):

markdown
---
heist: <heist-name>
date: YYYY-MM-DD
status: pending-review
mode: greenfield
---

# Reconnaissance Dossier: <Heist Name>

## Objective
<What the Don wants to build — restated in Don's words, plus interpreted objective>

## Workspace State
<One paragraph: what currently exists. If empty, say "empty workspace — greenfield".>

## Idea Framing
- Problem: <the actual problem>
- Who has it: <audience>
- Evidence: <what the Don offered; if none, say "no evidence offered — to be grilled">
- Hidden assumptions:
  - <assumption> — risk if wrong: HIGH/MEDIUM/LOW

## Analogues
| Name | What it does | Strengths | Weaknesses | License/Hosting |
|------|--------------|-----------|-----------|-----------------|
| ... | ... | ... | ... | ... |

## Prior Art & Patterns
- <pattern / protocol / algorithm> — <URL> — relevance: <how it applies>

## Constraint & Risk Survey
- <constraint> — source: <URL>

## Existing Test Coverage
<Near-empty in greenfield mode — note what, if anything, exists.>

## Dependencies
<Near-empty in greenfield mode — list any the Don named.>

## Relevant Ledger Entries
### Applicable Insights
- <insight reference + summary>
### Applicable Negative Constraints
- NEVER <constraint> — Source: fails/YYYY-MM-DD-<topic>.md

## Risks and Unknowns
<Domain risks surfaced by the Constraint & Risk Survey; unknowns the analogues search could not resolve.>

## Recommended Scope
<Suggested boundaries — since there is no codebase to constrain scope, scope is the IDEA's own bounds: which analogue features to adopt, which to reject, which sub-problems are in/out.>

The Don reviews this dossier the same way. The proceed menu (Step 4) is unchanged.

Standard Mode (existing codebase)

When the workspace contains a real codebase (5+ source files OR a recognizable project manifest), run the standard survey below.

Associate TaskWhat to Survey
Codebase StructureFile tree, key directories, framework detection, entry points
Existing TestsTest files, coverage areas, test framework, passing/failing status
Dependenciespackage.json / requirements.txt / go.mod etc., versions, known issues
DocumentationREADME, existing specs, API docs, inline documentation
Ledger SearchSearch docs/gangsta/insights/ and docs/gangsta/fails/ for entries with tags matching the objective
ConstitutionRead docs/gangsta/constitution.md for applicable Commandments and Negative Constraints

Step 3: Synthesize Dossier

Compile Associate reports into a structured Reconnaissance Dossier.

Dossier Format (Standard Mode)

Save to: docs/gangsta/<heist-name>/recon/YYYY-MM-DD-recon-dossier.md

In greenfield mode, use the Greenfield Dossier Format defined above instead.

markdown
---
heist: <heist-name>
date: YYYY-MM-DD
status: pending-review
---

# Reconnaissance Dossier: <Heist Name>

## Objective
<What the Don wants to build/change>

## Codebase Overview
<Key files, directories, frameworks, patterns discovered>

## Existing Test Coverage
<What's tested, what's not, test framework and run command>

## Dependencies
<Key dependencies, versions, any concerns>

## Relevant Ledger Entries

### Applicable Insights
- <insight reference + summary>

### Applicable Negative Constraints
- NEVER <constraint> — Source: fails/YYYY-MM-DD-<topic>.md

## Risks and Unknowns
<Anything that couldn't be determined, areas of concern>

## Recommended Scope
<Suggested boundaries for the Heist based on the intel>

Step 4: Present to Don

Save the Dossier file (Step 3), then present its contents to the Don in chat.

DO NOT include the proceed menu in the dossier file. The menu is a chat message only — present it to the Don after the dossier summary. Present it through the platform's native interactive selection tool (OpenCode question, Claude Code AskUserQuestion); only fall back to the plain-text numbered list when no such tool exists.

Required gate — The Sit-Down must not be skipped:

The Sit-Down (spec drafting and Contract signing) is a required phase. The Don may only choose whether The Grilling runs before it — but The Sit-Down itself must always run.

If the Don requests to skip The Sit-Down, explain that the Contract is required before any implementation work begins and re-present the menu below.

The proceed menu MUST use exactly this option set — do not paraphrase, abbreviate, or add options:

How do you want to proceed?

  1. Approve the dossier + run The Grilling → Multi-agent debate on architecture, then The Sit-Down
  2. Approve the dossier + skip The Grilling → Proceed directly to The Sit-Down (spec drafting)
  3. Adjust scope — Add/remove anything from the phases before we commit
  4. Request more intel — Deploy Associates to dig deeper into a specific area

Presentation — use the platform's native selection tool, not plain text:

  • In OpenCode, present these four options via the question tool (interactive select/choose UI). Do NOT dump the numbered list as plain text and wait — route it through the selection tool so the Don clicks a variant.
  • In Claude Code, use the AskUserQuestion tool with the same four options.
  • Only fall back to the plain-text numbered menu above when no interactive selection tool is available on the current platform.

Wait for the Don's explicit choice before taking any action.

  • Choice 1 → Invoke gangsta:the-grilling, then gangsta:the-sit-down
  • Choice 2 → Invoke gangsta:the-sit-down
  • Choice 3 → Clarify scope changes, update the dossier, re-present
  • Choice 4 → Deploy targeted Associates, update the dossier, re-present

Proceed with one of the choices above to maintain spec integrity (Omerta Law 5).

Checkpoint

Write checkpoint after the Don approves (choices 1 or 2):

yaml
---
heist: <heist-name>
phase: reconnaissance
status: completed
timestamp: <ISO 8601>
next-action: <"Proceed to The Sit-Down" | "Proceed to The Grilling">
artifacts:
  - docs/gangsta/<heist-name>/recon/YYYY-MM-DD-recon-dossier.md
---

Omerta Compliance

  • Introduction Rule: Associates dispatched by Underboss, reports collected by Underboss
  • Rule of Availability: Dossier and checkpoint saved to files
  • Rule of Truth: All dossier claims cite specific files, line numbers, Ledger entries, OR URLs (greenfield mode). Uncited analogue/prior-art claims are invalid.
  • Spec is Law: Proceed menu presented exactly as specified — no options added, removed, or paraphrased
  • Mandatory Gate: The Sit-Down is never skipped — no path leads directly to The Hit or Resource Development
  • Greenfield Mode: Internet searches (analogues, prior art) require URL citations in the Dossier; fabricated analogues violate Rule of Truth

Frequently asked questions

What does the Reconnaissance AI skill do?

Use when beginning a new heist — deploys associates to survey the target codebase, existing tests, dependencies, documentation, and the ledger to produce a reconnaissance dossier for the don's review

Why use Reconnaissance on TypingMind?

Because you install it once and use it with any model. Reconnaissance is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Reconnaissance in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/kucherenko/gangsta/tree/master/skills/reconnaissance. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Reconnaissance?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Reconnaissance?

As many as you like. As long as a model supports skills, you can use Reconnaissance with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Reconnaissance AI skill free?

Yes. It is published on GitHub by kucherenko under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇