skills.rest
TMI-apps
TMI-appsOFFICIAL
Explore all skills by this author →
WebsiteGitHub

architecture-repair2

Identify and repair semantic architectural violations across multi-module codebases.

2|Updated Dec 22, 2025
Search Tags:#architecture#refactor#code-quality#semantics#dependency-analysis#architecture-checks
One-click install
npx skills add https://github.com/TMI-apps/boilerplate-vite-supabase-mui-cursor --skill architecture-repair2
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture-repair2
Source: https://github.com/TMI-apps/boilerplate-vite-supabase-mui-cursor/tree/main/.cursor/skills/architecture-repair2
Command: npx skills add https://github.com/TMI-apps/boilerplate-vite-supabase-mui-cursor --skill architecture-repair2

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Complement automated checks by surfacing semantic architecture violations, guiding human-friendly refactors that automated tools miss.

Core Features & Use Cases

  • Semantic analysis to identify misplaced concerns, missing abstractions, and feature boundary violations.
  • Dependency impact analysis (count dependents, locate import sites) to inform safe moves.
  • Structured move guidance with Phase-based workflow, including manual and agent-based options.
  • Documentation of findings and prioritized recommendations for incremental refactors.

Quick Start

Run automated architecture checks, review detected semantic issues, and plan the top-priority refactor.

Frequently Asked Questions about architecture-repair2

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

FAQPage Schema
How do I find semantic architecture violations that automated checks miss?▼

Semantic architecture violations are identified by analyzing misplaced concerns, missing abstractions, and feature boundary issues across multi-module codebases. This supplements automated tooling to surface structural problems requiring human-friendly refactoring.

What is the best way to plan a safe refactor for cross-feature dependencies?▼

Planning a safe refactor for cross-feature dependencies requires dependency impact analysis to count dependents and locate import sites. This informs structured move guidance using a phased workflow for manual or agent-based execution.

How do I document architecture validation findings for incremental refactors?▼

Architecture validation findings are documented with prioritized recommendations for incremental refactors. This provides structured move guidance and actionable records to ensure safe, well-documented code transitions.

Does dependency analysis work for assessing missing abstractions in multi-module codebases?▼

Dependency analysis works for assessing missing abstractions in multi-module codebases by evaluating cross-feature dependencies and misplaced concerns. It identifies import sites and dependents to inform safe architectural moves.

When do I need semantic architecture checks instead of automated tooling?▼

You need semantic architecture checks when automated tooling misses structural issues like feature boundary violations and missing abstractions. This approach surfaces human-friendly refactors for complex semantic problems.

Can I use a phased workflow for both manual and agent-based refactoring?▼

A phased workflow supports both manual and agent-based refactoring options. It provides structured move guidance to ensure safe transitions when repairing semantic architectural violations across modules.

Related Skills

Explore More Software Engineering Skills→
smarmen86smarmen86

review

Analyze git diffs against base branches for SQL vulnerabilities and code defects.

Community
Advanced
vobbilisvobbilis
1

code-refactoring

Automate code refactoring with import tracking and a four-phase workflow.

Community
Advanced
VKirillVKirill
15

gitnexus-impact-analysis

Analyze dependency and execution-flow impact for changed symbols using gitnexus tools.

Community
Intermediate
ArabelaTsoArabelaTso
142

component-boundary-identifier

Analyze Python codebases to identify component boundaries and detect architectural violations.

Community
Intermediate