Results for “implementation”

Generates complete, copy-paste ready implementation documentation from a PR plan, including code blocks and verification checklists.

Creates detailed, bite-sized implementation plans from specs or requirements, with exact file paths, code, and test commands for TDD workflows.

Guides implementation of new model architectures in NeMo AutoModel through five phases: discovery, implementation, registration, validation, and testing.

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

Writes an actionable markdown implementation plan to .hermes/plans/ without executing code, using bite-sized tasks, exact paths, and complete code examples.

Guides the agent through structured protocols for writing technical specifications, implementation plans, and summaries, with file naming and task directory conventions.

Turns a mature product plan into a rough implementation plan with high-level steps, maturity and verification marks, and a risks section.

WAI-ARIA implementation, roles, states, and properties.

JWT implementation, token management, refresh patterns, and security.

Loads an implementation plan, reviews it critically, executes each task with verification, and reports completion, stopping to ask for help when blocked.

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

Loads a written implementation plan, reviews it critically, executes all tasks with verification, and reports completion, stopping to ask for help when blocked.

Breaks a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local Markdown file in ./plans/.

Verifies each step of a rough implementation plan against source code and current documentation, attaching proof and marking steps as verified or unverified.

Turns requirements into a precise, dependency-aware implementation plan.

JWT implementation, token management, refresh patterns, and security.

Create a detailed, step-by-step implementation plan for a feature or project. Load when the user asks to plan a feature, create a technical roadmap, break down a PRD into tasks, design an implementation strategy, or sequence engineering work. Also triggers on "how should we build this", "implementation plan for", "technical breakdown", "task list for", or any request to turn a high-level requirement into a concrete execution plan. Supports phased rollouts, architecture-first, and MVP-focused planning.

Transforms a rough idea into a detailed design document with an implementation plan through iterative requirements clarification, research, design, and planning.

Weed the Allium garden. Find where Allium specifications and implementation code have diverged, and help resolve the divergences. Use when the user wants to check spec-code alignment, compare specs against implementation, audit for spec drift or violations, sync specs with code or code with specs, or verify whether the implementation matches what the spec says.

Conducts structured requirements workshops to produce feature specifications, user stories, EARS-format functional requirements, acceptance criteria, and implementation checklists.

Surface and clarify unknowns before prompting, log deviations during implementation, and verify understanding after, using HTML artifacts that pair prompts with outputs.

Turns a spec or requirements into a detailed, bite-sized implementation plan with exact file paths, code, and test steps for engineers with no codebase context.

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

Executes a written implementation plan in a separate session, reviewing it critically, running tasks with verification, and stopping to ask for help when blocked.

Compare MoonSpec story breakdown output against the current repository implementation, preserve fully implemented stories as skipped, narrow partially implemented stories to remaining work, and rewrite the story breakdown handoff before issue creation.

Use when turning technical implementation details into clear maintainable documentation.

Use for lightweight implementation, edits, and straightforward coding tasks.

Creates detailed, step-by-step implementation plans from specs or requirements, with task decomposition, file structure, and test-driven development instructions.

Generate a comprehensive SEO strategy and implementation roadmap for new or existing websites, including competitive analysis, content planning, and technical foundation.

Implements features and writes code based on Plans.md tasks, with quality gates and routing to sub-skills for feature implementation and test writing.

Write an implementation plan from an approved architecture and MVP scope. Use when the team needs milestones, workstreams, dependency ordering, acceptance criteria, and execution sequencing that connect product intent to shippable engineering work.

Create systematic QA checklists to verify that design implementations match specifications across visual accuracy, layout, interaction, content, accessibility, and cross-platform categories.

Universal opt-out mechanism implementation across US state privacy laws. Covers Global Privacy Control (GPC) signal technical implementation, state-by-state recognition requirements, browser detection methods, authenticated vs unauthenticated handling, and compliance testing.

Structured brainstorming for projects and features. Explores multiple options before implementation.

Use before writing any implementation code — enforces RED-GREEN-REFACTOR cycle.

Server-Sent Events implementation, streaming patterns, and real-time updates.