What is the Project Evolution Injector?

A Lead Full-Stack Engineer skill for surgical refactoring and architectural fixes driven by research reports.

How does it ensure safety?

It enforces full-stack type-safety sync, performs idempotent writes, respects immutable anchors, and adds evolution traceability.

What outputs does it produce?

Production-ready code and an INJECTION_LOG.md that records all changes and rationale.

Project Evolution Injector

npx machina-cli add skill Vit0lze/Project-Evolver-Framework/project-evolution-injector --openclaw

Files (1)

SKILL.md

2.8 KB

Project Evolution Injector

This skill acts as a Lead Full-Stack Engineer. It executes the surgical refactoring and architectural updates proposed in project-field-explorer reports, adhering to strict senior engineering standards.

1. Trigger & Context

Trigger: "Use the project-evolution-injector skill to implement the fixes described in [Report Names]."

Context Retrieval:

Read GLOBAL_MAP.md for project vision.
Read the specific Field Research Report(s) provided by the user.
Read the Target Manifest from the report to identify the Blast Radius.

2. Advanced Engineering Functions

A. Full-Stack Type-Safety Sync

Constraint: Never break the contract.

If you modify a Backend Model/API response:
- IMMEDIATELY locate and update the corresponding Frontend Interface/Type or DTO.
- Do not leave the frontend in a broken state.

B. Idempotent Implementation

Constraint: Check before writing.

Before injecting code, SCAN the file.
If the fix or matching logic already exists, ABORT the write for that specific part.
Prevent duplicate imports, redundant functions, or double-implementation of logic.

C. Business Logic Safeguard

Constraint: Values are immutable.

Cross-reference the Golden Rules and Immutable Anchors from the Report.
Ensure the new structure yields the exact same business outcome as the old messy code.

D. Atomic Senior Coding

Constraint: Code must be pristine.

SOLID: Enforce SRP (split large functions).
DRY: Extract repeated logic into helpers.
KISS: Prefer simple, readable logic over "clever" one-liners.
Self-Documenting: Variable names must explain intent.

E. Evolution Traceability

Constraint: Leave a trail.

Insert a discreet comment above major architectural changes:
```
// Refactored by Evolution-Injector: Solution [SOL-ID]
```

3. Execution Standard

Analyze: Understand the Report and target files.
Plan: Check dependencies and imports.
Inject: Apply the changes atomically.
Sync: Update related types immediately.
Log: Record actions in INJECTION_LOG.md.

4. Output

Code: High-performance, production-ready code (No 'diff' previews, just the result).
Log: Generate INJECTION_LOG.md using the template.

Source

git clone https://github.com/Vit0lze/Project-Evolver-Framework/blob/main/Skill Files/project-evolution-injector/SKILL.mdView on GitHub

Overview

This skill acts as a Lead Full-Stack Engineer to implement surgical refactors and architectural fixes proposed in research reports. It enforces full-stack type safety, safeguards business logic, and upholds atomic, clean-code standards. It also ensures evolution traceability and proper logging.

How This Skill Works

Analyze the report and target files, including GLOBAL_MAP.md, field reports, and the Target Manifest. Plan dependencies, verify imports, and perform an atomic inject that does not duplicate logic. Immediately sync affected types and leave an evolution trace with a comment above major changes, then log in INJECTION_LOG.md.

When to Use It

When implementing high-level fixes identified by project-field-explorer reports.
When a backend model/API response changes require frontend DTO updates to stay in sync.
When changes must be idempotent and avoid duplicate injections or imports.
When enforcing SOLID, DRY, and KISS principles for architecture-level refactors.
When traceability is required and you need an evolution log of the changes.

Quick Start

Step 1: Analyze the Report and target files (GLOBAL_MAP.md, Field Reports, Target Manifest).
Step 2: Plan changes, scan for existing fixes, and prepare an atomic injection with type updates.
Step 3: Inject changes, sync related types, and log in INJECTION_LOG.md.

Best Practices

Always read GLOBAL_MAP.md and the Target Manifest to understand blast radius.
Keep a strict frontend-backend type-safety sync; update interfaces/DTOs immediately.
Scan files before injecting to ensure the fix isn't already present.
Make changes atomic and well-documented; apply SOLID, DRY, and KISS principles.
Annotate major changes with the evolution comment: // Refactored by Evolution-Injector: Solution [SOL-ID].

Example Use Cases

Refactor a legacy user-auth module to align backend response with frontend DTOs.
Split a monolithic function into SRP components while preserving behavior.
Replace repetitive logic with reusable helpers across services.
Introduce strict type-safety across backend APIs and corresponding frontend interfaces.
Add evolution traceability comments and update INJECTION_LOG.md after an architectural change.

Frequently Asked Questions

Add this skill to your agents