flagrare-agent-skills

agent-skills

Thirty-three skills that wrap around your development cycle in Claude Code. They turn tickets into ATDD plans, smoke-test features against a running app or service, hunt down bugs with runtime evidence, guard commits against doc drift, run seven-axis code review, draft changelogs that read like patch notes, and review PRs with full context from your tracker and design tools.

All skills are namespaced under flagrare:* to avoid collisions with other plugins. Installing this marketplace adds /flagrare:intake, /flagrare:work-prep, /flagrare:smoke-test, /flagrare:wrap-up, /flagrare:pr-reviewer, and twenty-eight more to every Claude Code session.

Install

bash <(curl -sL https://raw.githubusercontent.com/Flagrare/agent-skills/main/install.sh)

One command. It registers the marketplace, installs the flagrare plugin, and makes all thirty-three skills available. Restart Claude Code or run /reload-plugins afterward.

If you prefer to clone first:

git clone git@github.com:Flagrare/agent-skills.git && ./agent-skills/install.sh

Already installed on an older version?

If you're on a release before 1.3.1, the cached version of /flagrare:update has obsolete logic baked into its text and can't update itself. Run the canonical updater directly from GitHub once, it will heal any stale marketplace, plugin, or settings state:

bash <(curl -sL https://raw.githubusercontent.com/Flagrare/agent-skills/main/update.sh)

After this one-time bootstrap, /flagrare:update works for all future versions because it now just calls the same script from main.

What each skill does

Planning and context

/flagrare:intake reads a ticket (via Jira MCP, Linear, GitHub CLI, or a pasted URL), dispatches parallel subagents to follow every linked doc and PR, and assembles a context brief. Before asking clarifying questions, it grounds the brief in the actual code via /flagrare:codebase-explore, so questions reference specific files (src/x.ts:84) instead of abstract architecture. Hands off to /flagrare:atdd-plan.

/flagrare:atdd-plan produces an implementation plan in Claude Code's native plan mode. It enters plan mode via EnterPlanMode, runs /flagrare:codebase-explore to ground the plan in real files, and produces a plan-mode plan that must include 3-5 behavior-first acceptance tests defining "done" before implementation and any non-trivial structural decisions named as design patterns with a one-line rationale. ExitPlanMode closes with the native approve/edit/reject button UI. The skill stops at the plan; it does not write implementation code.

/flagrare:work-prep orchestrates the full ticket-to-plan workflow. It calls /flagrare:intake first (which now grounds the brief in code before asking codebase-aware clarifying questions), then /flagrare:atdd-plan (which runs its own thorough exploration pass and produces an ATDD-first plan). One command from ticket to plan.

/flagrare:codebase-explore maps conventions, reusable utilities, analogous features, and data flows for a planned change. Returns raw findings only (no plan, no tests). Used as the codebase grounding step by /flagrare:intake, /flagrare:atdd-plan, and /flagrare:ticket-creator, or standalone when you need to understand a feature area.

/flagrare:tdd-writer drafts Technical Design Documents for large projects (2+ weeks). It fetches context from Jira, Confluence, Figma, and Notion via MCP, analyzes the actual codebase, and marks every unverified claim explicitly, nothing is assumed. It writes through /flagrare:write-docs, so the result reads as narrative a reviewer can follow start to finish (what's proposed, why, and how) rather than a checklist with the prose removed.

/flagrare:ticket-creator writes well-structured tickets as reviewable markdown files, then pushes to any tracker (Jira, Linear, GitHub Issues, Shortcut, Asana, Trello) via MCP or CLI after you review and approve. Before drafting, it calls /flagrare:codebase-explore to find specific file paths, conventions, and prior attempts, so the ticket points at path/to/file.ts:42 instead of gesturing at "the relevant area". For spec/TDD-to-backlog flows it dispatches the explorations in parallel. After drafting, it polishes the Context section via /flagrare:write-docs so the prose reads like a senior engineer wrote it, not a template.

Learning

/flagrare:tutor is on-demand Socratic tutoring mode. Claude switches from doing the work to teaching you how to do it, questions instead of answers. You pick scope per call (tutor against current context, against a named topic, or instead of implementing the thing Claude was about to build) and persona in ascending intensity (Echo for calm/observational, Cipher for puzzle-handler, Vex for pushes-hard). Refuses to reveal the answer until you explicitly ask or accept a stuck-offer at three consecutive stalls. Exits only on explicit close phrase ("stop tutoring"), no model-side mastery gate. On first invocation in a repo, asks whether to record per-session summaries to .flagrare/tutor-log.md as a learning-path log.

Quality gates

/flagrare:smoke-test validates the feature you just implemented against a running instance. For UI work it drives a browser via Playwright MCP and diagnoses failures with Chrome DevTools MCP; for backend work it hits the running service through the project's existing test framework. Auto-detects domain from the diff (UI, backend, or full-stack). Tests every acceptance criterion plus exploratory edges (long inputs, slow network, auth matrix, idempotency, observability spans, the 403/404 tenant-leak), fixes every gap or bug found, then captures the working trajectory as a permanent Playwright spec or test file before declaring done. Ten-minute budget.

/flagrare:bug-bash runs a prescribed test plan against a real running system with evidence at every step. Ingests test cases from Notion (via the Notion MCP), markdown files, PR descriptions, or pasted text. Drives the UI via Chrome DevTools MCP or Playwright MCP; hits backend endpoints via Postman CLI, curl, or HTTP MCPs. Walks every prescribed case (the strict pass), then layers a five-lens exploratory pass: viewports, edge inputs, multi-actor flows in isolated browser contexts, codebase-driven concerns, and extra context the user provides (meeting transcripts, follow-up Slack threads). Lands results in a local markdown audit file by default, then optionally writes back to the source of truth, filling Eng QA columns and adding entries to the linked bug database in the team's own voice. Strict rule throughout: never claims a bug it didn't itself reproduce. Distinct from /flagrare:smoke-test, which is narrower and scoped to the feature the author just implemented; bug-bash is wider, longer-running, and often runs against features other people built.

/flagrare:staleness-audit diffs your staged changes against the repo's documentation surfaces (README, ADRs, public exports, doc comments, test names, changesets) and flags drift before it lands in history.

/flagrare:implementation-review launches seven parallel subagents: plan-gap detection, use-case coverage, missing test scenarios, test philosophy (Kent Dodds Testing Trophy), SOLID violations, Clean Code violations, and security. The security check pulls in /flagrare:security-audit. Every check reports its coverage, and a check with unexplained skips cannot report clean.

/flagrare:security-audit is the collection's security pass. It reviews the staged diff for HIGH-confidence, concretely exploitable vulnerabilities (injection, broken authn/authz, secrets and data exposure, unsafe deserialization, crypto misuse, SSRF), scoped to the change plus its trust boundary, and audits dependencies with the repo's own package manager when a lockfile moved (degrading to an advisory flag when the auditor is not installed). Every finding carries a concrete exploit path; theoretical noise is dropped. Runs as Check 7 of /flagrare:implementation-review and standalone on demand.

/flagrare:wrap-up runs automated checks (tests, lint, types), invokes /flagrare:implementation-review, then layers additional SOLID and Clean Code review for anything not covered. The combined report tells you whether to commit or fix first.

/flagrare:release-check detects the project's release mechanism, decides whether a release is due, and drafts a semver bump with a value-focused changelog entry.

/flagrare:ux-audit drives the running app via Chrome DevTools MCP through every reachable route and every visible affordance, screenshots each state, and writes a severity-ranked findings table (.ux-audit/FINDINGS.md) with location, why-it's-painful, and recommended fix. Accepts an optional scope ("UX audit the onboarding flow") to restrict to specific routes; defaults to all routes when no scope is given. Pretends to be a first-time user, surfaces jargon, mystery glyphs, dead-end empty states, choice paralysis, color-only signals, jarring tone, mobile-first violations. Goal-locked so it can't exit before coverage is complete. Installs Chrome DevTools MCP automatically if not already available.

/flagrare:debug-hunt is evidence-first debugging for bugs that are hard to reproduce, intermittent, or where previous static-analysis fixes have failed. It sets an explicit /goal (the bug no longer reproduces), then loops through Hypothesis → Instrument → Reproduce → Analyze → Fix until that goal is met. In Phase 1 it offers to invoke /flagrare:smoke-test to surface evidence from a live instance before touching code. When the repo has tests, Phase 4 invokes /flagrare:atdd-plan to write a failing acceptance test before the fix, so the bug is captured before it's killed. All instrumentation is tagged [DEBUG-HUNT] for clean removal once the fix is verified.

/flagrare:five-lens-review spawns five parallel persona subagents, Senior PM, Senior Product Engineer, Senior Product Designer, Senior Design Engineer, and a realistic end user, each examining the same product-direction question through their discipline's lens, then synthesizes convergent themes, disagreements, and a single actionable recommendation. Use when a user-facing decision has multiple competing constraints (lifecycle behaviour, data-model trade-offs, destructive actions, UX choices that touch retention) and a single-perspective answer would silently lock in the wrong default.

Review

/flagrare:pr-reviewer fetches linked Jira tickets, Figma designs, and Notion docs via MCP, then spawns five parallel subagents for systematic code review (correctness, security, tests, SOLID, clean code). Every subagent finding is confirmed against the actual code before it earns a comment, so inflated severity and invented line numbers never reach a colleague's PR, and every finding dropped in that pass names the fact that disproved it. Each subagent reports which files it covered, so a review that quietly skipped half the diff cannot read as a clean one. What survives becomes friendly, humanized GitHub comments, each marked introduced or pre-existing, posted as a pending review you submit yourself.

/flagrare:open-pr creates a pull request that follows the repo's PR template. It reads .github/PULL_REQUEST_TEMPLATE.md, fetches linked tickets for context (tracker-agnostic), and fills each section with narrative prose (not file enumerations). Descriptions explain what changed from both a product and code perspective, link relevant tickets, and include specific testing notes.