From a product idea.
To a change you can ship.

Turns interviews, documents and product data into a product brief. Separates evidence from assumptions, records decisions and defines what to work on next.

Challenges a vague idea, compares alternatives and checks whether the work already exists. Produces a focused handoff brief without changing application code.

Uses simulated personas to explore a flow and surface recurring objections. The results are explicitly synthetic hypotheses to validate with real users.

Builds a neutral prototype from a selected product flow, using simulated data and visible assumptions. Lets the team test navigation and recovery before detailed design.

Turns an unclear product or UX idea into a scoped direction, interaction contract and validation plan. Can also review an existing concept or prepare an implementation handoff.

Compares client requirements with what a platform actually implements. Builds an evidence-backed epic and story map, including failure paths and missing capabilities.

Converts a product brief or phased spec into epics, stories and tasks with acceptance criteria. Keeps each item connected to the product decisions behind it.

Creates one actionable tracker issue from a brief, checks for duplicates and links a covering spec or concrete implementation guidance. Does not implement the change.

Clarifies existing issues, applies workflow labels and checks readiness for implementation. Identifies missing specifications without editing application source.

Creates the business architecture above individual features: domain language, entities, identity, workflows and user stories. Checks gaps against the platform before implementation begins.

Develops a feature spec from open questions through architecture, contracts and phased delivery. Each phase has testable steps; it can also review an existing specification.

Writes a feature specification autonomously, recording assumptions and publishing a design-only pull request. Adds UI evidence when available and keeps high-stakes decisions gated.

Audits a specification against the real codebase, project rules and protected contracts. Returns a readiness verdict, risks and a remediation plan without editing the spec or code.

Creates screen briefs from the repository’s design contract, components and tokens. Also audits existing designs for inconsistencies with that contract.

Plans and implements a task in an isolated worktree, runs validation and self-review, then opens a labeled pull request. Progress is tracked so unfinished work can be resumed.

Handles larger plans with explicit tasks, incremental commits, handoff notes and regular verification checkpoints. Finishes with the full validation gate and a pull request.

Picks up an existing pull request from its execution plan and continues implementation, validation and review. Can reconstruct a plan when the PR does not have one.

Continues a long-running PR from its saved task table and handoff context. Preserves incremental commits, checkpoint verification and the original delivery plan.

Resolves an existing spec and routes it into implementation, review and UI verification. Reuses an existing spec PR branch when possible and delivers a ready pull request.

Classifies an issue and follows the appropriate path: verify and repair a bug, or resolve a spec and implement a feature. Works in isolation and returns a reviewed PR.

Checks the current branch and tracker before repair work starts. Detects already-fixed, duplicated or claimed issues and reports when no action is needed.

Traces a confirmed defect to the code that owns it. Produces a focused diagnosis, affected files and repair approach without changing the repository.

Implements the minimal repair identified by root-cause analysis, adds regression coverage and runs validation. Leaves committing and opening the PR to the next step.

Turns an error or regression into a reproducible diagnosis and a test that demonstrates the failure. When asked to fix it, applies and verifies a minimal repair without committing.

Answers a narrow framework or dependency question using the exact installed version, its shipped guidance and source. Returns a read-only evidence chain and an application-level conclusion.

Checks extension points and smaller alternatives before copying a dependency component into your repository. Helps make the ownership and future upgrade implications explicit.

Checks a diff, branch or PR for correctness, security, compatibility and quality. Runs configured validation and returns severity-ranked findings and a review verdict.

Reviews a PR in an isolated worktree, publishes a verdict and manages workflow labels. When changes are needed, runs an autofix and re-review loop.

Finds eligible unreviewed pull requests and reviews them one at a time. Skips drafts, blocked work and PRs already claimed by another agent.

Updates a PR and resolves review findings, failing CI and UI verification gaps. Leaves it ready for approval; this skill does not merge the PR.

Examines a PR, specification or branch for OWASP risks and less obvious attack paths. Reports findings without modifying the target and keeps live exploit details private.

Combines security analyses across a set of changes into one report with severity totals, coverage and follow-up work. Sensitive live findings are withheld from published reports.

Walks real user tasks and UI states in a browser, including errors and narrow screens. Produces evidence-backed UX findings ranked by user impact.

Discovers how the application starts and creates reusable launch and teardown scripts. Prepares the browser provider and a shared environment descriptor for subsequent tests.

Explores the running application before creating and executing integration or end-to-end tests. Uses the project’s own runners, conventions and test environment.

Maps changed files to affected units and dependencies, then selects a safe subset of tests. Falls back to full suites when the impact cannot be narrowed reliably.

Exercises a UI change in a real browser and captures screenshots with a pass/fail report. Produces verification evidence without editing source or merging.

Turns merged PRs into a practical verification plan: testing order, where to click, what to check and possible failure cases. Produces Markdown and HTML runbooks.

Creates an interactive test runbook for a PR, issue or branch. Executes browser checks, records reproducible defects and keeps evidence alongside AI and human results.

Runs all configured validation commands and fixes straightforward failures. Commits and pushes only when publication was explicitly requested and every required gate passes.

Commits and pushes prepared work, then opens or reuses a pull request with the shared template and workflow labels. Handles the issue handoff when the work came from a tracker.

Reads open PRs, reviews, CI and labels to separate ready, almost-ready and blocked work. Reports the blockers without changing or merging anything.

Submits approval and squash-merges a selected PR when review and QA gates permit it. Routes fixable blockers back to repair instead of bypassing checks.

Diagnoses a PR’s current state and chains the skills needed to move it forward. Does not merge unless merging was explicitly enabled, and respects the QA gate.

Drafts a categorized release entry from merged pull requests, checks contributor credit and delivers the update as a documentation PR.

Connects recent PR outcomes to tracker issues. Closes issues only when a merged PR has an authoritative closing reference, and adds context for other outcomes.

Turns actionable PR feedback or an implementation gap in a design document into a tracked issue. Checks existing work to avoid duplicate follow-ups.

Inspects the repository and configures validation, labels, tracker and browser providers. Generates missing workflow documents from the project’s actual setup.

Adds discovery roles, readiness criteria and product decision rules to an existing delivery setup. Updates the relevant configuration and marked documentation sections.

Extracts design tokens, components and screen patterns from the repository into a reusable UX contract. Preserves the team’s manual design decisions on refresh.

Writes AGENTS.md guidance derived from the repository: how to work, which decisions need input, what is prohibited and how to verify a change.

Authors an OM skill from a brief or splits an oversized skill into focused reference files. Preserves behavior and follows the collection’s workflow conventions.

Applies relevant migrations after a skills upgrade, updating local descriptors and configuration while preserving customizations. Leaves the changes available for review.

Reads installed skills and the repository’s task routing guidance to answer what to use next. Bases recommendations on what is actually available in the project.

Analyzes finished pull requests and agent markers to identify clean runs, recoveries and recurring blockers. Helps explain where the delivery pipeline needs improvement.

Reproduces a real agent failure in an evaluation harness, then fixes it with a focused knowledge change. The new case must demonstrate the failure before the fix.

Reviews an evaluation result or shared session bundle and returns pass, fail or inconclusive. Gives recorded tests and controller-owned evidence precedence over semantic judgment.

Prepares a sanitized session bundle, changed files and privacy report locally. Publishes only after you review the contents and explicitly confirm the destination.