codebase-planner

Analyze repository state to classify development tasks into four complexity lanes.

Updated May 9, 2026
One-click install
npx skills add https://github.com/yes506/ai-driven-items --skill codebase-planner
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: codebase-planner
Source: https://github.com/yes506/ai-driven-items/tree/main/skills/codebase-planner
Command: npx skills add https://github.com/yes506/ai-driven-items --skill codebase-planner

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires python3, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill prevents over-engineering and under-planning by automatically determining the appropriate scale for code changes, ensuring that every task receives the exact level of architectural rigor it requires.

Core Features & Use Cases

  • Scale-Based Triage: Classifies requests into micro, local, feature, or system lanes to match the complexity of the task.
  • Automated Workflow: Manages git worktrees, interface skeleton generation, and self-verification artifacts for complex system changes.
  • Use Case: When starting a new feature, use this Skill to generate a validated interface skeleton and a Mermaid dependency graph, ensuring your architecture is sound before writing a single line of implementation code.

Quick Start

Invoke the codebase-planner skill to analyze the current repository and propose a planning strategy for your upcoming feature implementation.

Frequently Asked Questions about codebase-planner

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

FAQPage Schema
How do I determine the right planning scale for a new software feature?

Planning scale is determined by analyzing repository state and project requirements to classify changes into micro, local, feature, or system complexity lanes. This triage ensures architectural rigor matches the exact needs of the task.

What's the best way to generate interface skeletons before writing implementation code?

Interface skeleton generation is automated by orchestrating git worktree creation and producing self-verification artifacts. This enforces strict docstring schemas and human-in-the-loop gates to ensure downstream implementation readiness.

How do I prevent over-engineering small code changes in an automated workflow?

Automated workflow triage prevents over-engineering by matching requests to appropriate complexity lanes. Micro and local tasks receive lighter scaffolding, while system changes trigger full dependency graphs and interface skeletons.

Does codebase-planner require python3 to manage git worktrees and architecture scaffolding?

Yes, python3 is required to run the scripts that manage git worktree creation, interface skeleton generation, and self-verification artifacts across the four complexity lanes.

When do I need a Mermaid dependency graph for architecture planning?

A Mermaid dependency graph is generated for complex system changes to validate architecture soundness before implementation begins. This visual artifact ensures structural integrity and dependency clarity for large-scale features.

Can I use automated planning triage for micro changes without generating unnecessary scaffolding?

Yes, scale-based triage classifies micro changes to skip unnecessary scaffolding. The automated workflow applies strict docstring schemas and interface skeletons only when the task complexity requires it.