afc:architect

Analyze codebase architecture and record architectural decisions.

7|Updated Feb 19, 2026
One-click install
npx skills add https://github.com/jhlee0409/all-for-claudecode --skill afc-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: afc:architect
Source: https://github.com/jhlee0409/all-for-claudecode/tree/main/skills/architect
Command: npx skills add https://github.com/jhlee0409/all-for-claudecode --skill afc-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps users understand and improve their codebase's architecture, ensuring design quality and consistency.

Core Features & Use Cases

  • Architecture Analysis: Provides insights into module relationships, data flow, and dependency structures.
  • Design Advice: Offers recommendations for placing new features and refactoring existing code.
  • ADR Recording: Documents architectural decisions in a standardized format.
  • Use Case: A developer is unsure where to implement a new user authentication module. They can use this Skill to get recommendations based on the current project structure and architectural rules.

Quick Start

Ask the architect skill to review the state management strategy in the codebase.

Frequently Asked Questions about afc:architect

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

FAQPage Schema
How do I analyze codebase architecture and understand module dependencies?

To analyze codebase architecture, you can explore module relationships, data flow, and dependency structures. This process provides insights into your project's design and verifies import directions using code exploration and critic loops.

What is an ADR and when should I record architectural decisions?

An ADR, or Architectural Decision Record, is a standardized document capturing design choices. You should record architectural decisions whenever significant structural changes occur to maintain design consistency and track the rationale behind your system design.

How do I evaluate refactoring existing code without breaking the system design?

Evaluating refactoring involves analyzing the current codebase architecture to ensure changes align with established rules. You can assess the impact on module relationships and data flow to verify import directions and maintain structural integrity before modifying the code.

Can I get design advice on where to place new features in my codebase?

Yes, you can get design advice for placing new features by analyzing your current project structure. This approach evaluates existing architectural rules and module dependencies to recommend the most appropriate location for new implementations.

What's the best way to enforce architectural rules during code review?

The best way to enforce architectural rules during code review is by analyzing the codebase structure and verifying import directions. This ensures new code adheres to established design patterns and maintains desired dependency constraints through automated critic loops.

Why does my system design allow circular dependencies and how can I fix them?

System design allows circular dependencies when import directions are not properly enforced. You can fix them by analyzing the codebase architecture to identify the violations and refactoring the modules to align with your established architectural rules.