maestria-co
42 verified skills
task-plan-phase-investigation
Load when the task's scope is unclear, the approach is unknown, or research into external libraries or services is needed before planning is possible.
research
context-review
Scans the codebase and synchronizes `.context/` documentation with the actual state of the code. Use this at the start of any architect or design task when the context cache is stale (older than 5 days) or missing.
development
find-context-template
Locate the context_template/ directory so initialize-repo and initialize-workspace can proceed. Use this whenever those skills need the template path and it isn't already known — triggered automatically by initialize-repo, initialize-workspace, and initialize-monorepo at startup, or directly when a user says "where is the context template", "find the skill kit template", or "I can't find context_template".
tools
implementing-features
Implements a feature, bug fix, or refactor from a clear specification. Use when: the task has clear acceptance criteria, a bug is diagnosed and the fix is understood, or code needs refactoring with a clear goal. Do not use when: the spec is unclear, an architecture decision still needs to be made, or the task needs to be broken into multiple steps first.
development
initialize-repo
Automates the setup of `.context/` for a new project. Use this skill whenever someone mentions setting up a new repository, onboarding a project to the agent system, bootstrapping context, or when you detect a project has no `.context/` directory. Also use when someone says "initialize", "set up", or "configure" in relation to project context, or when installing the skill kit for the first time. Skip only when `.context/` already exists and is populated — in that case use `context-review` instead.
data-ai
designing-systems
Makes a system design or technology decision and documents it as an Architecture Decision Record (ADR). Use when: introducing a new technology or service, designing a new system component (schema, API contract, service boundary), refactoring at non-trivial scale, or resolving competing technical approaches. Do not use when: the decision is an implementation detail within an already-decided approach, a naming convention choice, or a one-off decision with obvious rationale.
development
initialize-workspace
Bootstrap agent context for every project in a VS Code multi-root workspace. Use when setting up the agent system across a multi-project workspace, when someone says "initialize all projects in this workspace", "set up agent context for all our repos", or "I have a .code-workspace file and need to get all projects bootstrapped". Runs initialize-repo (or upgrade-repo) per project and generates workspace-level cross-project context.
development
common-constraints
Universal behavioral rules that prevent catastrophic agent failures — rationalization loops, unchecked claims, scope creep, and convention violations. These constraints are always active during any agent work. Consult this skill whenever you're about to declare work complete, when you've failed at the same approach multiple times, or when modifying code. If you catch yourself saying "it should work" without evidence, this skill applies.
development
context-document-guidelines
Ensure .context/ documentation is specific, useful, and high-quality. Use when creating or reviewing context docs — triggered by "write a context doc for this", "how should I document this pattern?", "update the context docs", "is this context doc good?", "review our .context/ files", or any time documentation in .context/ is being created, updated, or evaluated. Bad context docs mislead agents — this skill prevents that.
development
context-loader
Teaches agents how to efficiently discover and read `.context/` files. Use this skill at the start of every task — any time you begin work on a feature, bug fix, refactoring, test writing, or architecture decision. Also use when resuming work after a context reset, switching between tasks, or whenever you're unsure which context files are relevant. If you're about to start coding without checking project context first, stop and use this skill.
development
dependency-management
Update, audit, and manage project dependencies safely. Use whenever someone says "update dependencies", "we have a security vulnerability", "this package is outdated", "fix the npm audit warnings", "upgrade [library] to latest", "check for outdated packages", or when a dependency audit reveals CVEs. Works across all package ecosystems (npm, pip, Maven, NuGet, Cargo, Go modules).
development
design-first
Triage whether a task needs architecture planning before implementation. Use this skill at the start of every non-trivial task to decide whether to design first or implement directly. Especially important when the task involves new modules, data model changes, API design, technology choices, or cross-cutting changes affecting 3+ files. If you're about to start coding a complex feature without a design, pause and use this skill first.
development
initialize-monorepo
Bootstrap .context/ for a monorepo with multiple packages or services. Use when setting up the agent system for a monorepo — triggered by "initialize this monorepo", "set up context for our monorepo", "we have a packages/ directory and need context docs", "our Nx/Turborepo/Lerna workspace needs bootstrapping", or any time a multi-package repo has no .context/ and needs to be onboarded. Creates both a root-level overview and per-package context directories.
documentation
resolve-repo-context
Use when a manager agent needs to determine the correct context root for a task and the repo type is not a plain project — workspaces, monorepos, and multi-module repos all require this resolution before delegating to sub-agents.
data-ai
jira-story
Format a structured story spec into a Jira-ready user story. Used by the product-manager agent to produce the final Jira output — do not gather requirements here, just format them. Also invocable directly when someone says "format this as a Jira ticket", "turn this spec into a Jira story", or "write this up for Jira".
development
start-worktree
Set up a git worktree to work on multiple branches in parallel without stashing or losing in-progress changes. Use when someone says "create a worktree", "I need to work on two branches at once", "set up parallel development", "I got a hotfix while my feature is still in progress", "how do I review this PR without disrupting my work", or "can I run tests on both branches simultaneously?". Each worktree is a separate directory sharing the same git history.
development
systematic-debugging
4-phase debugging process (Reproduce → Root-Cause Trace → Defense-in-Depth Fix → Verify) for reliable issue resolution. Use this skill whenever investigating a bug, diagnosing unexpected behavior, debugging test failures, troubleshooting production incidents, or when something "worked yesterday but doesn't today". If you find yourself changing code hoping the bug disappears without understanding why, stop and use this skill instead.
development
task-plan
Defines the canonical plan.md format used as a handoff document between agents and across context boundaries. Use this skill whenever creating a new task plan, resuming work on a task with an existing plan, updating an in-progress plan, or when writing a plan that another agent (or yourself after context reset) needs to pick up cold. If a task has 3+ steps or spans multiple sessions, you need a plan.md and this skill tells you the format.
development
task-plan-phase-architecture
Load when the task's primary concern is structural decisions — new modules, shared library changes, new external integrations, schema changes, or cross-service boundaries.
development
task-retrospective
Structured reflection after completing tasks to capture lessons learned. Use this skill after finishing any medium or complex task, after encountering surprising behavior, after a task that took much longer than expected, or after debugging a tricky issue. If you learned something during a task that would help next time, use this skill — the knowledge captured here feeds into `context-maintenance` for promotion to permanent docs.
development
upgrade-repo
Safely upgrade a language version, framework, or major dependency. Use when someone says "upgrade Node to v22", "migrate to React 19", "we need to get off this old version", "update our framework", or "how do we upgrade X?". Also triggers when a security advisory requires a version bump. Scope is infrastructure only: manifests, lock files, build configuration, and source changes required by the new version. Content drift discovered during an upgrade (outdated docs, stale patterns) is out of scope — delegate those to `context-maintenance`. Prevents the most common upgrade pitfalls: skipping migration guides, multi-major jumps, and losing rollback options.
development
using-skills
Teaches agents how to discover, select, and invoke skills from the skill library. Use this skill whenever you're uncertain which skill applies to a task, when composing multiple skills for complex work, or when you need to understand what skills are available. This is your go-to when facing an ambiguous task and need to figure out the right approach before diving into implementation.
development
verification-checklist
Evidence-based verification process to run before marking any task complete. Use this skill every time you're about to report that work is done — for features, bug fixes, refactoring, or any code change. This catches the most common failure mode: declaring "done" without proof. If you're finishing up and about to tell the user the task is complete, run this checklist first.
development
writing-tests
Writes and runs a test suite for a piece of code, covering happy path, edge cases, error cases, and security cases. Use when: implementation is complete and needs test coverage, a bug needs a reproduction test and fix validation, or code needs coverage before a refactor. Do not use when: the code under test is not yet implemented, or the spec is still unclear.
development
task-plan-phase-implementation
Load when the primary work is writing code and the path is clear. Provides the pre-dispatch checklist, @coder delegation structure, deviation handling, and progress tracking.
development
task-plan-phase-completion
Load after the primary concern skill's work is done, to close any task. Covers code review, context updates, retrospective, and completion summary.
development
researching-options
Investigates a technical question and produces an opinionated recommendation with evidence. Use when: an unknown blocks planning or implementation, a library or approach needs evaluation before adoption, multiple valid options exist and a comparison is needed, or security and performance implications need assessment. Do not use when: the answer is obvious, it's an implementation detail within an already-decided approach, or it's a business/product decision.
development
planning-tasks
Breaks an ambiguous goal into an ordered, concrete, executable task list with acceptance criteria and dependencies. Use when: the goal has 3+ distinct steps, multiple areas of the codebase will be touched, or scope is unclear enough that wrong assumptions could waste significant effort. Do not use when: task is a single well-defined action or the user has already provided a step-by-step breakdown.
development
linear-story
Format a structured story spec into a Linear-ready issue. Used by the product-manager agent to produce the final Linear output — do not gather requirements here, just format them. Also invocable directly when someone says "format this for Linear", "create a Linear issue for this", "write this up as a Linear ticket", or "turn this spec into a Linear story".
development
commit-discipline
Git commit conventions and branch management standards. Use this skill whenever making commits, creating branches, reviewing commit history, or preparing code for a pull request. Also use when you notice messy commit history, unclear messages, or files that shouldn't be committed. If you're about to run `git commit`, consult this skill first.
development
agent-evaluation
Use when evaluating or auditing an agent system design, reviewing agent definitions for role overlap or responsibility leakage, or when orchestrator routing clarity, skill responsibility, or sub-agent job clarity is in question.
testing
asana-story
Format a structured story spec into an Asana-ready task. Used by the product-manager agent to produce the final Asana output — do not gather requirements here, just format them. Also invocable directly when someone says "format this for Asana", "create an Asana task for this", "write this up as an Asana story", or "turn this spec into an Asana ticket".
development
agentic-evaluation
Evaluate agent definition files (.agent.md, system prompts) against industry best practices and produce a structured report with scores, findings, and actionable rewrites. Use this skill whenever the user asks to review, audit, evaluate, score, or improve an agent file — even if they just say "check this agent" or "is this agent any good". Also triggers for requests like "what's wrong with this agent", "review my prompt", or "grade this system prompt".
development
code-identifier
Find where specific code lives in a large or unfamiliar codebase. Use whenever someone asks "where is X implemented?", "which file handles Y?", "find the code that does Z", "where does the auth logic live?", "I need to locate the payment processing code", or any time navigation through an unknown codebase is needed. Also use when an agent needs to locate an entry point before making changes.
development
code-quality-rules
Use when conducting a code review and evaluating whether a change meets project quality standards.
development
context-maintenance
Keeps `.context/` documentation accurate and current. Use this skill after completing any non-trivial task, when you've learned something new about the project, when promoting lessons from retrospectives, when pruning stale task folders, or when you notice documentation that's outdated or duplicated. If you just finished a task and learned something worth preserving, this is the right skill — even if the user doesn't explicitly ask. For full codebase-level syncs, use `context-review` instead.
development
context-specialist-impl
Internal backing skill for the @context-specialist agent. NOT for direct invocation. Covers tree-position detection and .context/ initialization for leaf, branch, and root nodes.
testing
knowledge-graduation
Graduate validated patterns from `.context/` to reusable local skills. Use this skill when reviewing `.context/` files and noticing patterns that keep recurring across tasks, when retrospectives show the same lessons being re-learned, or during periodic context review cycles. Also use after completing 10+ tasks when patterns should be mature enough to evaluate for promotion.
testing
post-meeting
Capture meeting decisions, action items, and context as a durable written record. Use immediately after any meeting — triggered by "write up the meeting", "document what we decided", "capture meeting notes", "I just got off a call and need to record the decisions", "send a meeting summary", or whenever important decisions were made verbally and need to be preserved. Prevents decisions from evaporating and action items from falling through the cracks.
development
task-plan-phase-testing
Load when the task's primary concern is tests — fixing failing tests, adding coverage to existing code, or implementing a feature test-first (TDD).
development
testing-discipline
Test quality standards and TDD practices. Use this skill whenever writing tests, reviewing test quality, deciding what to mock, choosing test strategy, or evaluating test coverage. Also use when you notice tests that are brittle, slow, or always passing regardless of implementation. Complements `writing-tests` (which handles test execution) with the principles that make tests actually useful.
testing
writing-skills
Use when creating a new skill, editing an existing skill, or helping a user author a skill for this system. Covers structure, discoverability, quality, and discipline hardening.
testing