joao-aires/sdlc
Full SDLC activities, artifact and activity systems, requirements and quality-attribute design, delivery, operations, platform/AWS, security and governance assurance.
Route development work across activities, stopping points and supporting methods. Use to choose what activity applies, what it produces, where it stops, what may follow, and which artifact or method to use.
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.
Design, implement or review how an application loads, validates and changes configuration and secrets across local, CI and production targets. Use for source precedence, typed settings, environment parity, runtime reload, multi-tenant defaults, feature-flag boundaries, secret delivery, rotation and scanning.
Maintain engineering artifacts across intent, change, system knowledge, implementation, delivery and entry planes. Use to choose an artifact type, resolve its home, apply its contract and quality bar, and check cross-artifact consistency.
Plan capacity and improve application cost from measured demand and spend evidence. Use for concurrency, scaling, saturation, resource sizing, infrastructure or provider cost tradeoffs, budget reviews and architecture changes.
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.
Translate applicable legal, contractual and assurance requirements into system boundaries, controls, ownership and evidence. Use for compliance design, GDPR, CCPA/CPRA or SOC 2 readiness, and scoped SaaS assurance assessments including subprocessor, residency, export and deletion evidence.
Plan, implement or review database backups, restore verification and application disaster recovery. Apply when persistence, deployment topology, migrations or recovery requirements change; use the actual database, Kubernetes operator and cloud provider guidance.
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, AI behavior or architecture for a requested change before implementation. Use when the user wants to settle a solution, compare directions or review a proposal, including a continuation of an exploratory conversation. Use for consequential design alternatives; produce options, type-appropriate linked artifacts and a recorded decision.
Take a rough business idea, feature, refactor or improvement through clarification, design, implementation, testing and review in one requested engagement. Use when the user asks to build a feature, including after a discussion of its requirements or design. Reuse agreed decisions and fill only gaps needed to implement safely.
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.
Investigate and repair reported incorrect software behavior when the user asks for a fix. Compare observed behavior with intent, reproduce the defect, apply a focused repair, verify it and hand off the evidence. Use for local or authorized engineering repair after an incident.
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.
Guide to writing an architecture or product decision record. Covers context, options, decision, consequences, status and supersession.
Guide to writing an architecture document set. Covers context, containers, components, runtime, data, interfaces, deployment, qualities, decisions and evidence.
Guide to writing a scoped assurance assessment. Covers applicability, service boundary, controls, evidence, gaps, disposition and ownership.
Guide to producing and reviewing C4 context, container and component views. Use for system boundaries, actors, responsibilities, directed dependencies, current versus proposed state and text equivalents.
Guide to producing and reviewing a compatibility matrix. Use for public surfaces, versions, platforms, runtimes, deprecation, migration and consumer evidence across libraries, CLIs and APIs.
Guide to writing a design proposal. Covers the decision, constraints, affected components, materially different options, linked artifacts, tradeoffs, seam and recommendation.
Guide to producing a design specification that implementation can build and verify from. Covers flows, wireframes, mockups, prototypes, states, content, components, responsiveness, accessibility, motion, assets, handoff and design QA.
Guide to writing an Engineering Change Record. Covers overview, problem, requirements, solution design, implementation, verification and decisions across a change.
Guide to writing an incident record. Covers impact, severity, ownership, timeline, mitigation, recovery verification, current state and follow-up.
Guide to writing an actionable issue. Covers context, intended outcome, scope, acceptance, constraints, verification, dependencies and ownership.
Guide to writing a blameless postmortem. Covers timeline, contributing conditions, what worked, actions, owners, verification and open questions.
Guide to writing a pull request description. Covers why, what changed, design impact, validation, risk, release and reviewer links.
Guide to writing a product brief or PRD. Covers problem, audience, outcome, scope, success signal, constraints, evidence and open decisions.
Guide to writing a repository README. Covers purpose, audience, quickstart, what it does, open-source adoption, honest claims, docs map, development, support, status and limits.
Guide to writing a release note or changelog. Covers what shipped, target, changes, migration, compatibility, verification and rollback.
Guide to writing a decision-oriented research report. Covers question, recommendation, evidence, alternatives, limits and open decision.
Guide to writing a request for comments or technical proposal. Covers problem, current state, affected components, proposal, alternatives, impact and open decision.
Guide to writing and reviewing operational runbooks. Covers triggers, prerequisites, diagnosis, mitigation, verification, escalation, recovery and exercise evidence.
Guide to producing and reviewing sequence views. Use for participant responsibilities, request ordering, synchronous versus asynchronous work, branches, failure, retry and recovery.
Guide to producing and reviewing state machines. Use for states, triggers, guards, terminal states, denied transitions, invariants and concurrent or retried behavior.
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 an agreed change in small verified increments. Use when the work is ready to build, whether the client provides slash commands and a Git flow or only local files and tests.
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.
Coordinate and investigate active service incidents using impact-led triage, reversible stabilization, causal evidence, escalation, communication and independent recovery verification across any application stack.
Define, automate, explore and evaluate user journeys across web, desktop and mobile applications, including browser extensions. Use for UI/API/persistence changes, interaction and visual consistency, authentication, authorization, lifecycle behavior and failing journey checks.
Implement, audit and maintain application/infrastructure logs, metrics, traces, client telemetry and collection pipelines during setup, feature work or recurring instrumentation improvements.
Plan and run recurring operational reviews of capacity, artifact retention, backup activity, dependency queues, expiring access, scheduled environments, and runbook ownership.
Decide whether and what to pursue for a feature, structural change, product area or new application. Use when discussion turns to what to ship first, what is in scope, whether it is feasible, or how to sequence and coordinate multiple changes.
Facilitate and follow up an incident postmortem: reconstruct evidence, analyse causes and response, derive testable learning actions, and verify that the controls actually work.
Assess whether a service, launch or material capability change is ready to be depended on in production. Use for a scoped readiness review of reliability and SLOs, observability and alerts, security and authority, capacity and failure behavior, recovery and rollback, runbooks, on-call and support, and open limits, without authorizing a release or certifying the service.
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 when a conversation moves from ideation to defining an actionable feature without authorizing code.
Prepare, review or verify an application release or deployment, whether merge-triggered continuous deployment or an explicitly authorized target action. Use for release readiness, post-rollout verification or an authorized target action; bare invocation prepares and reports rather than deploying.
Elicit, analyze, validate and maintain verifiable functional and quality requirements for features, refactors, new systems and architecture changes. Use as supporting expertise during refine when stakeholder needs, behavior, cross-system constraints or acceptance are materially uncertain.
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.
Create, exercise or audit an operational runbook. Use for alert response, recovery procedures, planned operations and recurring runbook maintenance; stop at a published and exercised procedure or a precise gap.
Design, implement or review features with security and privacy built into data flows, authorization and integrations. Apply to changes involving identities, user data, external inputs, dependencies or new trust boundaries; revisit protections as the application evolves.
Design, implement or review authentication, authorization and identity lifecycle across application stacks. Use for sessions, federation, passkeys, machine identity, tenant/resource access and contextual identity-framework selection.
Maintain operational security surfaces by inventorying, rotating and retiring credentials and by triaging, remediating and verifying vulnerabilities across dependencies, images, infrastructure and deployed targets.
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 current architecture: services, dependencies, deployment topology, journeys, C4/sequence views and interfaces from repository, documentation and runtime evidence. Use for setup, feature analysis, architecture documentation and 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, run and review checks; establish completion evidence for a change, journey, component or application. Use as part of implementation or the in-review step, or for an explicit verification request, 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.
Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.