Flagrare

agent-skills

Twenty-six 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 six-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-one 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 twenty-six 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.

/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