ink-and-agency

Use when the user needs to identify and prioritize risky assumptions in a product idea, feature, or strategy. Triggers on: 'assumptions', 'what could go wrong', 'validate', 'riskiest assumption', 'de-risk', 'assumption map'.

Use when the user needs to groom, refine, or clean up a product backlog. Triggers on: 'groom backlog', 'backlog refinement', 'backlog grooming', 'clean up backlog', 'refine stories', 'sprint refinement', 'backlog management'.

Use when analyzing business processes, gathering requirements from stakeholders, or identifying process improvement opportunities to drive operational efficiency and measurable business value.

Use when you need to develop comprehensive content strategies, create SEO-optimized marketing content, or execute multi-channel content campaigns to drive engagement and conversions. Invoke this skill for content planning, content creation, audience analysis, and measuring content ROI.

Use this skill before publishing any AI-generated content — blog posts, READMEs, release notes, commit messages, PR descriptions, documentation, or social posts. Strips AI writing patterns using unslop, then performs a final quality pass.

Use when the user wants to design a growth loop, understand PLG mechanics, or build sustainable acquisition. Triggers on: 'growth loop', 'flywheel', 'viral loop', 'PLG growth', 'product-led growth', 'growth mechanics', 'how do we grow', 'word of mouth'.

Draft a customer-facing release note for a Jira ticket by gathering the ticket context (summary, description, type, fix version, comments) and any linked GitLab merge requests / code changes, then synthesizing a clear, audience- appropriate release note. Runs a clarity-council quality pass over the draft. Read-only by default; the user may opt in at the end to publish the note as a Jira comment (or into a Release Notes field if one exists). Use when user says "draft release notes", "write a release note", "release note for [TICKET-KEY]", "what changed in this ticket", or invokes /issue-draft-release-notes with a ticket key.

Scan all open issues in a Jira project and identify likely duplicates using semantic comparison. Produces a markdown report listing each suspected duplicate pair with a probability score and reasoning. Read-only — never modifies, links, or transitions tickets. Default project key is read from memory (`reference_jira_default_project.md`); accepts an override project key. Use when user says "find duplicates", "duplicate check", "dedupe issues", "find duplicate tickets", or invokes /issue-dup-find with or without a project key.

Estimate story points for a Jira ticket using historical data and multi-persona scrum poker. Use when user says "estimate this ticket", "how many points", "story point estimate", "estimate [TICKET-KEY]", or invokes /issue-estimate-sp. Read-only — never modifies the ticket.

Analyze a Jira ticket by gathering full context from Jira and Confluence, following linked tickets, then running a clarity-council to identify gaps and ambiguities. Produces an actionable breakdown plan. All actions are read-only. Use when user says "break down this feature", "analyze this ticket", "feature breakdown", or provides a Jira ticket key for analysis.

Suggest Jira components for one ticket or sweep all open tickets in a project. Gathers context from Jira, Confluence, and GitLab, proposes a conservative set of existing components (or recommends new ones), and confirms with the user before any modification. Bulk mode default project key is read from memory (`reference_jira_default_project.md`); max 250 tickets, highest key first. Use when user says "suggest components", "tag components", "fix components", "categorize tickets", or invokes /issue-suggest-component with or without a ticket key.

Triage a bug or issue by gathering context (Jira ticket or free-form description), mapping the suspected code area via codebase-explain, hypothesizing root causes via clarity-council, and producing a structured triage report with ranked root-cause candidates and proposed solution paths. Read-only by default; the user may opt in at the end to publish the report as a Jira comment. Use when user says "triage this", "triage [TICKET-KEY]", "what's causing this bug", "help me find the root cause", or invokes /issue-triage with a ticket key or issue description.

Use when you need to draft contracts, review compliance requirements, develop IP protection strategies, or assess legal risks for technology businesses.

Use when architecting, implementing, or optimizing end-to-end legal licensing systems—from OSI standard selection and dependency compliance pipelines to proprietary deployment and risk monitoring.

Use when you need to establish project plans, track execution progress, manage risks, control budget/schedule, and coordinate stakeholders across complex initiatives.

Use when you need to conduct technical pre-sales activities including solution architecture, proof-of-concept development, and technical demonstrations for complex sales deals.

Use when you need to create, improve, or maintain technical documentation including API references, user guides, SDK documentation, and getting-started guides.

Use when you need to architect, optimize, or troubleshoot WordPress implementations ranging from custom theme/plugin development to enterprise-scale multisite platforms. Invoke this skill for performance optimization, security hardening, headless WordPress APIs, WooCommerce solutions, and scaling WordPress to handle millions of visitors.

Facilitates structured single-persona or multi-persona consultation for strategy, product, engineering, operations, and risk decisions. Use when the user requests a council, multiple perspectives, persona advice, tradeoff analysis, or iterative clarification and debate.

Two-axis review of the working diff since a fixed point — Standards (does it follow this repo's coding standards + a code-smell baseline?) and Spec (does it match the originating ticket/spec?). Runs both as parallel sub-agents. Use when the user wants to review a branch or work-in-progress changes, says "review since X", or asks for a pre-MR review before a merge request exists.

Analyze a git repository's history and produce an SVG treemap of file churn — area = lines changed, color = commit frequency. Use when user wants to find unstable areas of a codebase, predict bug-prone files, see "where do we change the most", spot refactor candidates, or invokes /codebase-churn.

Tell the agent to explain code with broader context and a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture.

Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.

Create a detailed refactor plan with tiny commits via user interview, then file it as an issue. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.

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

Build a piece of work (ticket, spec, or free-form request) through a tunable pipeline — test-first, verify, review, and track — where every phase can be skipped or tuned. Use when the user wants to actually build something, from a throwaway prototype to a CCB-gated feature.

Test-driven development — the red → green loop and the rules that make its tests worth keeping. Use when the user wants to build a feature or fix a bug test-first, mentions "red-green-refactor", TDD, or integration tests.

Use when designing new APIs, creating API specifications, or refactoring existing API architecture for scalability and developer experience. Invoke when you need REST/GraphQL endpoint design, OpenAPI documentation, authentication patterns, or API versioning strategies.

Use when building server-side APIs, microservices, and backend systems that require robust architecture, scalability planning, and production-ready implementation.

Use when you need to translate a DESIGN.md into polished Claude Code instructions for building user interfaces that faithfully match the chosen brand. Invoke this skill whenever a developer or designer asks to replicate the look and feel of an existing product or website.

Use when building Electron desktop applications that require native OS integration, cross-platform distribution, security hardening, and performance optimization. Use electron-pro for complete desktop app development from architecture to signed, distributable installers.

Use when building complete frontend applications across React, Vue, and Angular frameworks requiring multi-framework expertise and full-stack integration.

Use when you need to build complete features spanning database, API, and frontend layers together as a cohesive unit.

Use when designing or evolving GraphQL schemas across microservices, implementing federation architectures, or optimizing query performance in distributed graphs.

Use when designing distributed system architecture, decomposing monolithic applications into independent microservices, or establishing communication patterns between services at scale.

Use when building cross-platform mobile applications requiring native performance optimization, platform-specific features, and offline-first architecture, and when developing iOS and Android apps (native or cross-platform) with focus on performance and platform-specific user experience. Covers React Native and Flutter projects where code sharing must exceed 80% while maintaining iOS and Android native excellence.

Use when designing visual interfaces, creating design systems, building component libraries, or refining user-facing aesthetics requiring expert visual design, interaction patterns, and accessibility considerations.

Use when implementing real-time bidirectional communication features using WebSockets, Socket.IO, or similar technologies at scale.

Use when architecting, implementing, or optimizing end-to-end AI systems—from model selection and training pipelines to production deployment and monitoring.

Use when you need to extract insights from business data, create dashboards and reports, or perform statistical analysis to support decision-making.