apivr-methodology

Implement features in brownfield codebases using the APIVR-Δ methodology.

1|Updated Feb 22, 2026
One-click install
npx skills add https://github.com/Rynaro/homunculus --skill apivr-methodology
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: apivr-methodology
Source: https://github.com/Rynaro/homunculus/tree/main/.claude/skills/apivr-methodology
Command: npx skills add https://github.com/Rynaro/homunculus --skill apivr-methodology

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a rigorous, step-by-step methodology for implementing features in brownfield codebases, ensuring thorough analysis, planning, and verification.

Core Features & Use Cases

  • Evidence-Grounded Planning: Guides feature implementation through detailed analysis and test-anchored development.
  • Structured Self-Improvement: Incorporates phases for analyzing existing assets, planning strategies, implementing code, verifying results, and reflecting on failures or improvements.
  • Use Case: When tasked with adding a new API endpoint to an existing complex system, this Skill ensures all existing relevant code is discovered, potential conflicts are mapped, and a robust plan is created before implementation, minimizing regressions.

Quick Start

Follow the APIVR-Δ methodology to implement the new user authentication feature.

Frequently Asked Questions about apivr-methodology

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

FAQPage Schema
How do I safely implement features in an existing codebase without causing regressions?

Feature implementation in an existing codebase requires evidence-based planning and test-anchored development to minimize regressions. The APIVR-Δ methodology structures this through discovery, collision mapping, and verification phases before any code execution.

What is the best way to plan refactoring and feature implementation in brownfield projects?

Brownfield refactoring planning is best handled through structured asset discovery and collision mapping. This methodology generates robust strategies by analyzing existing code assets and mapping potential conflicts before implementation begins.

How does test-driven development anchor the feature implementation process?

Test-driven development anchors feature implementation by creating verification points during the Verify phase. Tests are established early to validate execution and ensure structured reflection captures any failures or necessary improvements.

Can I use this methodology for adding API endpoints to complex software systems?

Yes, this methodology suits adding API endpoints to complex systems by ensuring all relevant existing code is discovered first. It maps potential conflicts and creates a robust plan before implementation, directly minimizing system regressions.

When do I need a structured methodology for codebase analysis and feature implementation?

You need a structured codebase analysis methodology when adding features to complex, existing software environments. It becomes necessary when thorough discovery, evidence-grounded planning, and collision mapping are required to prevent unintended side effects.

What are the limitations of using a structured development methodology for software engineering?

A structured development methodology requires strict adherence to distinct Analyze, Plan, Implement, Verify, Reflect, and Delta phases. It may introduce overhead for simple tasks but is essential for complex, brownfield feature implementations where regressions are costly.