Packs

7 packs

PRD to Implementation Plan

Transform a raw product idea into a structured PRD and then into a technical implementation plan with issues.

11 skills · pack

Common base skills including documentation generators, implementation planning, and utility tools

7 skills · pack

Component Spec and Pattern Library

Document component anatomy, variants, and usage patterns for consistent implementation.

5 skills · pack

Growth Loop Implementation

Identify the right growth loop mechanism, then build the acquisition and expansion motions to drive it.

3 skills · pack

Implement Plan with Git Workflow

Execute a predefined implementation plan step by step using isolated git worktrees and structured version control.

6 skills · pack

Planning skills for the Han suite: specifying, planning, sequencing, breaking down, and stress-testing work before implementation. Home of plan-a-feature, plan-implementation, plan-a-phased-build, plan-work-items, and iterative-plan-review, plus the discussion-facilitator agent. Depends on han-communication and han-core; bundled by the han meta-plugin.

5 skills · pack

Reporting and summary skills for the Han suite. Turns feature specifications into plain-language stakeholder summaries (also called executive or business summaries) with diagrams, for sharing with non-technical stakeholders before implementation kicks off.

2 skills · pack

Results for “implementation”

22 skills

Creates detailed, bite-sized implementation plans from specs or requirements, with file structure, task decomposition, and TDD steps.

Chains architecture review, implementation, and pull request creation to take a story from design through to a convention-compliant PR.

lucaspmarie-a11y

Turns a brief product idea into working, verified code by orchestrating requirements analysis, planning, parallel implementation, QA, and multi-perspective validation.

subagent-driven-development

Executes implementation plans by dispatching a fresh subagent per task and running two-stage reviews for spec compliance and code quality.

subagent-driven-development

Execute implementation plans by dispatching a fresh subagent per task, with task review after each and a whole-branch review at the end.

Adversarially verify an implementation against its objective, acceptance criteria, definition of done, and prohibitions using fresh evidence. Use for completion gates, release readiness, or independent verification after implementation and review.

More results

Validate cryptographic implementations against known attacks and edge cases using Wycheproof test vectors.

Resolves legacy references to the e2e-runner capability by routing to the current runtime implementation, agent, or plugin skill.

tilegym-adding-cutile-kernel

Add a new cuTile GPU kernel operator to TileGym, covering dispatch registration, backend implementation, exports, tests, and benchmarks.

test-driven-development

Write tests before implementation code for new features, bug fixes, and refactoring, following the red-green-refactor cycle.

Guides systematic debugging by investigating root causes before proposing fixes, with structured phases for analysis, hypothesis testing, and implementation.

Implements work from a PRD or set of issues using TDD, typechecking, and regular testing, then reviews and commits the changes.

incremental-implementation

Delivers changes incrementally by building in thin vertical slices, testing and verifying each piece before moving to the next.

Implements features, fixes bugs, and refactors code by orchestrating domain-specific skills, following existing patterns, and verifying tests and lint pass.

Guides Go developers in building production-ready gRPC services, covering proto organization, server/client implementation, error handling, streaming, testing, and security best practices.

Refactors test files to improve behavioral coverage, clarity, structure, assertions, fixture setup, and mocking strategy, removing implementation-detail or low-value tests.

orch-change-feature

Orchestrate altering an existing, working feature to new desired behavior by updating tests first, then changing implementation, reviewing, and committing with gated approval.

verification-patterns

Provides grep-based patterns to verify that code artifacts are real implementations rather than stubs or placeholders, covering React components, API routes, database schemas, and hooks.

generate-testability-wrappers

Generate wrapper interfaces, default implementations, and DI registration code to make hard-to-test static dependencies in C# testable, using built-in abstractions like TimeProvider or custom wrappers.

agentskillexchange

eslint-rule-composer

Creates custom ESLint rules using the ESLint RuleTester API and AST Explorer patterns, generating rule implementations with auto-fix suggestions based on estree node types and scope analysis.

Implements a feature phase by phase from a phased JSON or Markdown plan, with configurable unit-test and quality-gate choices per phase, token-budgeted execution, resumable state, and TDD handoff.

Delivers a small, bounded code change through inspection, a mini-plan, implementation, testing, review, and adversarial verification. Use for bug fixes, configuration changes, and features expected to touch no more than five files.