skills.rest
marcocello
marcocelloCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

coding-architecture-deep-dive

Analyze component architecture, logic, and implementation tradeoffs before refactoring or migration decisions.

10|1|Updated Feb 22, 2026
Search Tags:#architecture#performance#refactoring#analysis#migration#reliability
One-click install
npx skills add https://github.com/marcocello/dot-codex --skill coding-architecture-deep-dive
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: coding-architecture-deep-dive
Source: https://github.com/marcocello/dot-codex/tree/main/skills/coding-architecture-deep-dive
Command: npx skills add https://github.com/marcocello/dot-codex --skill coding-architecture-deep-dive

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you evaluate whether a component's architecture, logic, and implementation choices are sound before you refactor, optimize, migrate, or change reliability and scaling decisions.

Core Features & Use Cases

  • Architecture Assessment: Map inputs, outputs, dependencies, state, boundaries, and failure paths for a specific component or workflow.
  • Reference Comparison: Compare the current design against a concrete alternative and decide whether to keep, partially adopt, or replace it.
  • Risk Analysis: Identify coupling, logic gaps, operational weaknesses, performance bottlenecks, and tradeoffs tied to real failure modes.
  • Use Case: Ask for a read-only review of a service that is timing out under load and get a grounded diagnosis with the smallest corrective change.

Quick Start

Use coding-architecture-deep-dive to assess the architecture of the specified component or compare it against the provided reference design.

Frequently Asked Questions about coding-architecture-deep-dive

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

FAQPage Schema
How do I identify architecture risks before refactoring a service?▼

To identify architecture risks before refactoring, map component inputs, outputs, dependencies, and failure paths to pinpoint coupling, logic gaps, and operational weaknesses tied to real failure modes for grounded corrective changes.

What is the best way to diagnose performance bottlenecks under load?▼

Diagnosing performance bottlenecks under load requires analyzing runtime constraints, traces, and metrics against current architecture designs to identify logic gaps and operational weaknesses causing timeouts.

How do I evaluate implementation tradeoffs for a migration?▼

Evaluate implementation tradeoffs for a migration by comparing your current design against a concrete reference design to decide whether to keep, partially adopt, or replace the architecture based on evidence-based boundary analysis.

Do I need architecture docs and runtime constraints to analyze reliability?▼

Yes, analyzing reliability requires repository contracts, architecture docs, and runtime constraints, while optionally using reference designs, incidents, traces, metrics, or deployment details for evidence-based failure analysis.

Related Skills

Explore More Software Engineering Skills→
managedcodemanagedcode
4

mcaf-observability

Design observability requirements for logs, metrics, traces, and alerting.

Official
Intermediate
OzeroHAXOzeroHAX
32

coder-system-design-perf-patterns

Select system-level performance patterns for latency, throughput, or cost constraints.

Community
Advanced
ryasrkryasrk

enterprise-agent-ops

Manage agent runtime lifecycle, observability, and security boundaries.

Community
Advanced
tuyenhttuyenht

performance-profiling

Audit web performance with Lighthouse and analyze JavaScript bundles.

Community
Intermediate