skills.rest
artk0de
artk0deCOMMUNITY
Explore all skills by this author →
GitHub

writing-plans

Generate structured implementation plans using repository impact signals from tea-rags MCP.

11|3|Updated Jan 29, 2026
Search Tags:#git#refactoring#codebase#mcp#task-decomposition#impact-analysis
One-click install
npx skills add https://github.com/artk0de/TeaRAGs-MCP --skill writing-plans-artk0de
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/artk0de/TeaRAGs-MCP/tree/main/.claude-plugin/dinopowers/skills/writing-plans
Command: npx skills add https://github.com/artk0de/TeaRAGs-MCP --skill writing-plans-artk0de

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the issue of generic, ungrounded coding plans by enriching task decomposition with real-world repository signals like git history, churn, and blast radius.

Core Features & Use Cases

  • Impact-Aware Decomposition: Sequences tasks based on actual code risk, ownership, and bug-fix history rather than just semantic similarity.
  • Proven Pattern Extraction: Identifies existing project templates and successful code patterns to guide new implementations.
  • Use Case: When refactoring a core module, use this skill to identify high-blast-radius files, assign tasks to the correct owners, and ensure the plan reflects the actual technical debt and stability of the codebase.

Quick Start

Ask the agent to draft an implementation plan for the specified files and include tea-rags impact enrichment.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create an implementation plan for refactoring a complex codebase?▼

Impact-aware decomposition generates structured implementation plans for refactoring by sequencing tasks based on actual code risk, file ownership, and bug-fix history rather than just semantic similarity.

What are the best ways to assess code risk before modifying a core module?▼

Assessing code risk requires analyzing repository-level impact signals like git history, code churn, and blast radius metrics to identify high-risk files and ensure technical debt is reflected in the plan.

Do I need an MCP server to generate data-driven coding plans?▼

Yes, you need the tea-rags MCP server integration to retrieve authorship, churn, and blast radius metrics for target file sets, which grounds the task decomposition in real-world repository signals.

Can I use git history to assign refactoring tasks to the correct owners?▼

Yes, you can use git history to assign refactoring tasks to the correct owners by retrieving authorship and churn metrics for target file sets through the tea-rags MCP server integration.

How does proven pattern extraction guide new feature implementation?▼

Proven pattern extraction guides new feature implementation by identifying existing project templates and successful code patterns within the codebase, ensuring new implementations align with established project conventions.

Related Skills

Explore More Software Engineering Skills→
artk0deartk0de
11

brainstorming

Enrich creative code brainstorming with git-based technical debt and hotspot signals.

Community
Advanced
kriegcloudkriegcloud
68

architecture-analysis

Analyze service dependencies and assess change impact using graph theory.

Community
Advanced
DVNghiemDVNghiem
20

repo-memory-graph

Builds and maintains a persistent knowledge graph of codebase architecture, conventions, bug history, ownership, and module relationships in .codebase/MEMORY.json.

Community
Advanced
esimplicityincesimplicityinc

superpowers-integration

Integrate Superpowers with domain agents to enforce structured, test-driven software delivery.

Official
Basic