joao-aires/development

Creates and maintains concise AGENTS.md and CLAUDE.md project instruction files. Use when asked to create AGENTS.md, update AGENTS.md, maintain agent docs, set up CLAUDE.md, document repository agent conventions, or keep coding-agent instructions minimal and reference-backed.

Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes: Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/spec asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to "review since X".

Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

Implement, review and prepare application changes for delivery with focused verification, practical CI/CD and operational evidence. Use for feature implementation, bug fixes, PR preparation, pipeline changes and deployment readiness.

Review dependency/runtime updates, vulnerability remediation or dependency-update PRs with release-note, compatibility and CI evidence. Use for explicit or configured maintenance jobs; auto-merge only under an established eligible-update policy.

Design UI interactions, backend contracts or architecture for a requested change before implementation. Use for flows, navigation, shared components, API/data/state behavior or consequential design alternatives; produce concise text and useful wireframes/mockups when needed.

Take a rough business idea, feature, refactor or improvement through clarification, design, implementation, testing and review in one requested engagement. Use for end-to-end development with consequential questions and explicit assumptions, not a promise of zero interaction or automatic deployment.

Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.

Performs security-focused differential review of code changes. Adapts analysis depth to codebase size, uses git blame for context, calculates blast radius by counting callers, checks test coverage of modified code, and generates a markdown report. Use when reviewing a PR, commit, or diff for security vulnerabilities, checking whether a change re-introduces a previously fixed bug, asking what else a change could break, or finding which modified code has no test covering it.

Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.

Develop a feature in an isolated Git worktree, make Conventional Commits and publish a concise pull request to the correct repository. Apply by default when starting feature work, continuing a feature branch, committing changes or preparing a PR; respect plan-only requests and existing contribution conventions.

A relentless interview to sharpen a plan or design.

A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.

Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.

Compact the current conversation into a handoff document for another agent to pick up.

Assess and address security/privacy weaknesses in the supplied feature, diff or repository. Use for a scoped hardening task with evidence-backed fixes and verification, preserving accepted architecture and task authority.

Implement a piece of work based on a spec or set of tickets.

Implement the result of /to-spec and /to-tickets in code.

Assess codebase improvement opportunities or implement a specified improvement objective. Use for architecture, performance, reliability, testability, UX consistency or developer-experience work; bare invocation discovers prioritized evidence-backed opportunities.

Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

Define, automate, explore and evaluate user journeys across web, desktop and mobile applications. Use for UI/API/persistence changes, interaction and visual consistency, authentication, authorization, lifecycle behavior and failing journey checks.

Plan implementation of agreed work using repository context, dependencies, verification and release consequences. Use for a bounded feature/refactor plan; do not turn a small fix into a mandatory planning workflow.

Establish or maintain an application repository's structure, stack constraints, scoped AGENTS.md, local setup and delivery conventions. Use when explicitly asked to start, organize or review a project, or when the requested change affects those foundations; keep ordinary feature work within existing conventions.

Writes, reviews, and debugs property-based tests — Hypothesis, fast-check, proptest, jqwik, rapid, and Echidna or Medusa for Solidity invariants. Use whenever tests should cover a whole input domain instead of a hand-picked list of examples: encode/decode and serialize/deserialize pairs, parsers, canonicalizers and normalizers, validators, numeric and Decimal types, comparators and sort order, data structures, and smart-contract state invariants. Also use when adding cases to an existing @given, fast-check, or proptest suite, when judging whether existing property tests assert anything real, and when a generator has shrunk a counterexample and you need to tell a wrong property from a genuine bug. Not for coverage-guided binary fuzzing (libFuzzer, AFL), mutation-testing campaigns, static analysis, benchmarking, or end-to-end UI tests.

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

Refine a rough idea, brief, conversation or optional tracker item into repository-aware actionable work. Use to establish scope, acceptance criteria, affected UX/API/data boundaries and material questions before implementation, including unattended refinement jobs.

Prepare or execute a named application release/deployment with artifact, configuration, compatibility and recovery verification. Use for deployment readiness or an explicitly authorized target action; bare invocation prepares and reports rather than deploying.

Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.

Design, implement, run or review controlled failure tests for application journeys, dependency outages, delays, worker loss and resource exhaustion. Use to verify bounded failure handling and recovery in an authorized isolated or non-production target; choose proportionate fixtures or experiments without requiring a chaos platform.

Conduct a retrospective on a coding session.

Review a PR, branch or current diff against its intended behavior and engineering standards, checking appropriate test evidence. Use for explicit reviews or configured PR-review jobs; default to assessment rather than source changes, publication or merge.

Establish a new application or adopt an existing repository, discover working commands and accepted constraints, and prepare a useful first slice. Use for explicit project setup or adoption; preserve an existing project layout and tooling.

Choose and evolve application architecture from product outcomes, existing system evidence and operating constraints. Use after product refinement for a new system or before planning a feature that changes service, data, client or integration boundaries; avoid architecture ceremony for small local edits.

Discover and document an application's services, dependencies, deployment topology and user/request/data journeys from repository, documentation and runtime evidence for setup, feature analysis or recurring architecture updates.

Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.

Select, add where needed and run checks for the current change or named journey, component or application. Use for unit/integration/contract/web/desktop/mobile verification and relevant performance/resilience checks within the authorized target scope.

Turn a decision you can't fully answer into a questionnaire for someone else to fill in.

Turn the current conversation into a spec and publish it to the project issue tracker: no interview, just synthesis of what you've already discussed.

Explain this plugin toolkit, available task entry points and supporting skills by SDLC phase or requested outcome. Use for help, command discovery, invocation syntax, automation examples and choosing a next development activity without starting it.

Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.