Ejecuta cualquier Skill en Manus
con un clic

Ejecuta cualquier Skill en Manus con un clic

learn-system

Estrellas28

Forks2

Actualizado30 de abril de 2026 a las 12:54

Explore and explain how a system, module, or codebase works. Use when the user is onboarding, trying to understand unfamiliar code, or building a mental model.

Instalación

Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.

Ejecutar en Manus

Fuente

hawkyre

hawkyre/hawk-skills

Abrir repositorio de GitHub Ver repositorios del creador

Descarga

Ejecutar en Manus

Ocupaciones relacionadasSOC

Basado en la clasificación ocupacional SOC

Desarrolladores de softwareOcupaciones informáticas y matemáticas·SOC 15-1252

SKILL.md

readonly

name	learn-system
description	Explore and explain how a system, module, or codebase works. Use when the user is onboarding, trying to understand unfamiliar code, or building a mental model.

Learn How Something Works

Process

Entry point exploration:
- What triggers this code to run
- High-level flow (what calls what, in what order)
- Key data structures and how they transform
- Where important decisions/branching happens
In Claude Code, use the Explore subagent for this — it keeps the main context clean.
Visual mental model: Draw a diagram (mermaid or ASCII) showing:
- Main components/modules
- Data flow between them
- External dependencies (DB, APIs, filesystem)
- Error handling boundaries
Save the diagram — visual models compress understanding.
Trace a specific flow: Walk through a concrete scenario step by step:
- Which functions are called, in what order
- What data looks like at each step
- "Interesting" parts (complex logic, non-obvious behavior)
Pick the most common scenario first, then trace edge cases.
Socratic verification (when the user states their understanding):
- What did they get wrong?
- What's missing?
- What would surprise them?
Telling the AI what you think is true and asking for corrections is dramatically more effective than open-ended questions.
Capture the understanding (if asked): Write a brief architecture doc:
- Purpose and scope
- Key concepts and data flow
- Common modification points
- Gotchas and non-obvious behavior

Rules

Start broad, go deep on specific areas when asked
Always trace at least one concrete scenario — abstract explanations don't stick
When the user states their understanding, correct misconceptions specifically
Use diagrams to compress understanding
Write down what you learned — it compounds across sessions
Big-output discipline. Heavy command output (project check, full git diff, repo-wide search, long log, large fetch) goes to /tmp/hawk-learn-system-<step>.log, then rg -n '<pattern>' /tmp/hawk-learn-system-<step>.log | head -50 extracts what you need. Read the file only with offset/limit. See README → Big-output discipline. Explore subagents must apply the same recipe to their captures.

Más de este repositorio

mismo repositorio

plan-large

hawkyre/hawk-skills

Plan a multi-PR feature, migration, or architectural change before writing code. Writes a `.plans/<slug>/` directory of HTML documents (with inline UI mockups and a review-tracking layer) — a 1-page `overview.html` for human review, a mandatory `data-model.html` that locks the schema before anything else, a terse `plan.html` of dependency-ordered increments, an ADR-style `decisions.html`, and a `verification.html` acceptance script. Use whenever the user says "plan this feature", "scope out the migration", "/plan-large", "architect this rollout", "I need a plan covering schema and API", "design this across multiple PRs", or "break this work up". Also use whenever the work touches a database migration, even if it's only two PRs — schema-first is the gate. Runs a blind self-review subagent before presenting. Do NOT use for single-PR changes — bail to `plan-small` at Step 0. Do NOT use to start implementing — that's `/implement-plan` after the plan is approved.

2026-06-2828

plan-small

hawkyre/hawk-skills

Plan a single-PR change end-to-end before writing code. Writes a terse `.plans/<slug>/plan.html` (HTML, with inline UI mockups where a screen changes, rendered through the shared design system) covering files to touch, data-model changes, edge cases, verification, and decisions/assumptions sourced to code or user. Use whenever the user says "plan this", "scope this out", "write up a plan for X", "/plan-small", "let's plan the new flag", or "plan before we start". Also use whenever the user describes a small feature without explicitly asking to plan — propose a plan before coding. Asks only what code can't answer (in-repo PRDs count), surfaces planned assumptions alongside questions, then runs a blind self-review subagent before presenting. Do NOT use for multi-PR work, schema migrations beyond adding a nullable column, or sequenced increments — bail to `plan-large` at Step 0. Do NOT use to start implementing — that's `/implement-plan` after the plan is approved.

2026-06-2828

code-audit-hardcore

hawkyre/hawk-skills

Aggressive cleanup audit scoped to the user's specified changes plus tangibly-relevant surrounding code. Same blind audit-* specialists as code-audit, with a maximum-improvement posture — any code in the expanded review scope that can be cleaner WILL be made cleaner. Small fixes applied inline; big fixes (>5 files, schema, public API, redesigns) routed through `/plan-small` or `/plan-large`. Plan-overrides — when the audit reveals the original plan was wrong — route through `/plan-large` by default. Always improve over preserve.

2026-06-2828

implement-plan-audited

hawkyre/hawk-skills

Execute a plan increment-by-increment with the audit-* specialists running independently at strategic checkpoints. Use whenever the user says "implement the plan with audits", "audited implementation", "run with audits", "implement with cleanup checkpoints", "audit as you go", or invokes /implement-plan-audited. Inherits the full per-increment verification loop from `implement-plan` (done-criteria evidence, layered retry ladder, file-divergence check, outcome records) and adds checkpoint annotation, blind parallel audits, audit-fix verification (each FIX closes its own loop), plan-override propagation, and BEHAVIOR_CHANGE.md artifacts. Two modes — `manual` stops between increments for user review; `auto` applies audit fixes and proceeds without interruption, designed for hours of unattended execution. Specialists are blind to the plan and the goal. Do NOT use for unaudited plan execution — use `implement-plan`. Do NOT use for one-shot audits of existing code — use `code-audit`. Do NOT use for planning or repl

2026-06-2828

implement-plan

hawkyre/hawk-skills

Execute an approved plan increment-by-increment with deterministic verification at each step. Use whenever the user says "implement the plan", "run the plan", "execute the plan", "work through the increments", "do the plan", or invokes /implement-plan. Done-criteria are checked against evidence on disk, not asserted from memory; failures escalate through a layered ladder rather than repeated identical attempts; existing code gets behavior-preservation tests before modification; file divergence (touched vs declared) is reconciled before each commit; structured outcome records land in the plan file. Designed for fresh sessions with no prior context. Do NOT use for planning itself — use `plan-small` or `plan-large`. Do NOT use for unplanned coding without a plan file — use `coding-process`. Do NOT use when the user wants audits in the loop — use `implement-plan-audited`.

2026-06-2828

review-plan

hawkyre/hawk-skills

Stress-test a plan file before committing to implementation. Catches architectural mistakes, convention violations, and missing dependencies while changes are still cheap. Invoked directly, not routed from coding-process.

2026-06-2828

Learn How Something Works

Process

Entry point exploration:

What triggers this code to run
High-level flow (what calls what, in what order)
Key data structures and how they transform
Where important decisions/branching happens

In Claude Code, use the Explore subagent for this — it keeps the main context clean.

Visual mental model: Draw a diagram (mermaid or ASCII) showing:

Main components/modules
Data flow between them
External dependencies (DB, APIs, filesystem)
Error handling boundaries

Save the diagram — visual models compress understanding.

Trace a specific flow: Walk through a concrete scenario step by step:

Which functions are called, in what order
What data looks like at each step
"Interesting" parts (complex logic, non-obvious behavior)

Pick the most common scenario first, then trace edge cases.

Socratic verification (when the user states their understanding):

What did they get wrong?
What's missing?
What would surprise them?

Telling the AI what you think is true and asking for corrections is dramatically more effective than open-ended questions.

Capture the understanding (if asked): Write a brief architecture doc:

Purpose and scope
Key concepts and data flow
Common modification points
Gotchas and non-obvious behavior

Rules

Start broad, go deep on specific areas when asked

Always trace at least one concrete scenario — abstract explanations don't stick

When the user states their understanding, correct misconceptions specifically

Use diagrams to compress understanding

Write down what you learned — it compounds across sessions

Big-output discipline. Heavy command output (project check, full git diff, repo-wide search, long log, large fetch) goes to /tmp/hawk-learn-system-<step>.log, then rg -n '<pattern>' /tmp/hawk-learn-system-<step>.log | head -50 extracts what you need. Read the file only with offset/limit. See README → Big-output discipline. Explore subagents must apply the same recipe to their captures.