agent-essentials

Restate the last message in plain human language, with no jargon.

Give a capable engineer a concise briefing on the critical facts and implications of an effort before it is built or after it is completed. Use when the human explicitly invokes $facts, and never otherwise; do not invoke this skill automatically.

Vendor skills from a GitHub repository into this repo. Use when asked to import, vendor, list, add, or update skills from another skills repository while preserving provenance and detecting local edits.

Use when given a well-scoped bug fix or small feature ticket from Jira. Investigates the ticket, researches the codebase, proposes a fix, then plans and implements on approval. Lighter alternative to the full deep-work pipeline for tickets that don't need multi-session design discussion.

Use when starting work on a ticket that needs refinement before entering the deep-work pipeline. Reads from Jira, pasted text, or a file, then interactively refines it into a structured ticket.md.

Use when a session is ending and you want to analyze process efficiency. Triggers on requests to review how a session went, evaluate context usage, or identify workflow improvements.

Load this skill before calling the `execute` tool. Teaches the Executor sandbox calling model: discover with `tools.search({ query, limit })`, inspect with `tools.describe.tool({ path })`, list sources with `tools.executor.sources.list({})`, then call the real tool by its full address. Use for SaaS APIs, remote systems, MCP/OpenAPI/GraphQL integrations, and auth/approval-managed actions.

Use when you need to deeply understand a PR, branch, or system/feature end-to-end. Triggers on "explain this PR", "walk me through", "how does X work", "tour of this change", "help me understand this system", "ramp me up on".

Use when phrases like 'give me an html report' are used in prompts or skills. Use when a caller has compiled content (sections, prose, code, diagrams) and wants to render it as a self-contained HTML technical report. Owns structural UX (TOC, scroll-spy, progress bar, marginalia, collapsible sections, SVG diagram cards) and visual design languages. Used by code-tour; intended for future report-producing skills.

Use when reviewing local branch changes before creating a PR. Triggers on requests to review current work, check branch quality, or get feedback on uncommitted or committed changes against the parent branch.

Use when you need fast, interactive code review of a PR with detailed explanations. Triggers on exploratory reviews, learning-focused feedback, or when you want to discuss findings before any action.

Use when you the user requests a quiz to test their understanding of a topic.

Use when a feature branch is ready for PR creation or an existing PR needs updates pushed. Triggers on "create PR", "submit PR", "push PR", "open PR", "write PR description", "fill out PR template", or when implementation is complete and needs to go upstream. Accepts optional context file paths for richer PR descriptions.

One-shot end-of-session shipping workflow. Use when the user says "yeet", wants zero-friction local changes to become a Jira-backed commit and draft PR, or asks to create/commit/push/submit a PR in one flow. Accepts an optional Jira key, Jira URL, or ticket title.

Use when code changes need independent adversarial review from a different model. Accepts git SHA range and optional spec file for compliance checking.

Use when an implementation plan needs independent adversarial review from a different model before implementation begins. Accepts plan file path or deep-work topic slug.

Use when the user wants to generate a Postman collection JSON file for a set of API endpoints. Triggers on requests to create Postman configs, API testing collections, or REST client imports from source code.

Consult opencode for a second opinion on design, review, or analysis. Building block skill — invoke when another skill or the user requests consultation. Uses server mode for observability (attach via TUI or browser).

Use when reviewing a pull request and you want to examine issues before posting comments. Triggers on PR review requests where human judgment on findings is needed.

Use when you have a plan from /rpi-plan (or any dw-05-format plan.md at ~/notes/context-engineering/<repo>/<slug>/) and want to execute it. Dispatches a fresh subagent per task with two-stage review (spec compliance → code quality), then runs a baked-in end-of-implementation audit that re-runs success criteria, checks the diff against the plan, and dispatches /quick-review across the SHA range.

Use after /rpi-research when you want an interactive, gated plan-creation flow. Produces a dw-05-format plan.md at ~/notes/context-engineering/<repo>/<slug>/ that /rpi-implement can execute. Interactive: presents understanding, design options, phase outline, then draft — each gated on user approval.

Use when starting the RPI flow and you want to deeply understand a question, system, or feature by reading the codebase before planning. Produces a durable research artifact at ~/notes/context-engineering/<repo>/<slug>/research.md that rpi-plan consumes.

Use when reviewing code, designing features, or evaluating architecture decisions. Surfaces the most relevant design principles and red flags from "A Philosophy of Software Design" contextually.

orchestrate sub-agents to accomplish complex long-horizon tasks without losing coherency by delegating to sub-agents

Use when investigating issues across terminal sessions, reviewing output from long-running processes, checking logs in other panes, or gathering context from multiple terminal workspaces during debugging or operations.

Use when needing context-efficient summaries of tmux pane content - test output, stack traces, application logs, or terminal narrative. Returns structured summaries instead of raw output to preserve conversation context.

Use when you have a plan written by /write-plan, or any dw-05-format plan at ~/notes/context-engineering/<repo>/<slug>/plan.md, and want to execute it. Use this rather than executing-plans when subagents are available.

Use when you have a small, well-scoped change that needs an implementation plan but doesn't warrant the deep-work pipeline's research/design phases. Use instead of investigate-and-fix when you want a durable plan artifact rather than a transient EnterPlanMode plan.