feature-design

Guide feature development from idea through codebase exploration and phased implementation planning.

2|Updated Apr 3, 2026
One-click install
npx skills add https://github.com/jscott3201/ai-agent-skills --skill feature-design-jscott3201
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feature-design
Source: https://github.com/jscott3201/ai-agent-skills/tree/main/skills/feature-design
Command: npx skills add https://github.com/jscott3201/ai-agent-skills --skill feature-design-jscott3201

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Drive a feature from idea to implementation-ready plan by exploring the codebase, capturing design decisions, producing phased tasks with complete code, and verifying the plan against the repository and constraints. It prevents scope creep by enforcing non-goals, records rationale for future recall, and produces mechanically verifiable tasks for execution.

Core Features & Use Cases

  • Guided multi-stage workflow: Context recall, code exploration, iterative clarification, research/design (conversational or formal), plan writing, self-review, verification, and handoff.
  • SeleneDB integration and provenance: Creates sessions and records Decisions, Documents, Milestones, and links between research and plans to enable cross-session recall and traceability.
  • Executable plans with exact artifacts: Produces implementation plans with exact file paths, complete code snippets, dependency graphs, test and verification commands, and rollback strategies for safe handoff.
  • Use case: Starting a medium-to-large feature where team alignment, decision traceability, and code-level correctness are required before execution.

Quick Start

Create a phased, implementation-ready plan for a new feature that includes design decisions, exact file-level tasks with complete code, and verification steps.

Frequently Asked Questions about feature-design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn a feature idea into an implementation plan with exact code tasks?

To turn a feature idea into an implementation plan, you need a guided workflow that explores the codebase, records design decisions, and generates phased tasks with exact file paths and complete code snippets. This process prevents scope creep and ensures mechanically verifiable execution.

What is feature design and why do I need decision records before coding?

Feature design translates requirements into executable plans, while decision records capture the rationale behind those choices. Using SeleneDB to store decisions enables cross-session traceability, preventing knowledge loss and ensuring team alignment before code execution.

How do I create a phased implementation plan that includes verification and rollback strategies?

Creating a phased implementation plan with verification and rollback strategies involves generating exact file-level tasks, complete code snippets, and dependency graphs. The plan must enforce non-goals and produce test commands to verify code correctness against repository constraints.

Can I use SeleneDB to track design decisions and document nodes for software projects?

Yes, you can use SeleneDB to track design decisions by creating sessions and recording Decisions, Documents, and Milestones. This integration links research directly to plans, enabling provenance and cross-session recall for medium-to-large software features.

Does this feature planning workflow support code generation for an existing repository?

Yes, this feature planning workflow supports code generation for an existing repository by exploring the codebase context, generating exact file paths, and writing complete code for each task. It verifies the generated plan against the repository constraints before handoff.

When should I use a formal feature design workflow instead of conversational planning?

You should use a formal feature design workflow over conversational planning when starting medium-to-large features that require strict team alignment, decision traceability, and code-level correctness before execution. It enforces non-goals and produces mechanically verifiable tasks.