ctx:architect

Decompose complex software architectures into dependency-mapped execution plans.

5|Updated Oct 14, 2025
One-click install
npx skills add https://github.com/Shakes-tzd/contextune --skill ctx-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ctx:architect
Source: https://github.com/Shakes-tzd/contextune/tree/main/skills/software-architect
Command: npx skills add https://github.com/Shakes-tzd/contextune --skill ctx-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you overcome the complexity of system design, make informed build vs. buy decisions, and structure projects for efficient, parallel execution. It ensures clarity and reduces rework.

Core Features & Use Cases

  • Structured Design Workflow: Follow a systematic process (Understand, Research, Specify, Decompose, Plan) for any technical challenge.
  • Build vs. Buy Analysis: Evaluate solutions with a clear framework to decide whether to build custom or integrate existing tools.
  • Task Decomposition: Break down large projects into manageable, dependency-mapped tasks, ready for parallel development.

Quick Start

Design a new user authentication system for a high-traffic web application.

Frequently Asked Questions about ctx:architect

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

FAQPage Schema
How do I break down a complex software architecture into manageable tasks?

Decompose complex architectures using a structured workflow: Understand the requirements, Research existing solutions, Specify functional needs, Decompose into dependency-mapped components, and Plan phased execution. This produces an executable design package with clear task dependencies ready for parallel development.

What's the best way to decide whether to build custom software or buy an existing solution?

Build vs. buy decisions require systematic evaluation of functional requirements, cost, timeline, and integration complexity. A structured design workflow compares custom solutions against existing tools, explicitly mapping dependencies and risks to guide informed choices aligned with project constraints.

How do I create a system design specification that reduces rework?

System design specifications require understanding requirements, researching available approaches, specifying functional needs explicitly, decomposing into mapped dependencies, and planning phased execution. This structured process ensures clarity, identifies risks early, and prevents misalignment before development begins.

Can I use this approach for large projects requiring parallel execution?

Yes. Decomposing complex projects into dependency-mapped tasks enables parallel development by clarifying which work streams can execute independently. The structured workflow produces explicit dependency maps and phased execution plans that coordinate parallel work across teams.

What happens if I skip the planning phase in system design?

Skipping planning phase creates hidden dependencies, unclear task sequencing, and execution bottlenecks. Comprehensive planning—including dependency mapping and risk assessment—ensures phased execution remains coordinated, prevents parallel work conflicts, and reduces costly rework.

How do I evaluate architectural solutions before committing to implementation?

Evaluate solutions by specifying functional requirements, researching candidate approaches, mapping explicit dependencies and constraints, identifying risks, and planning execution phases. This assessment delivers a comprehensive design package that validates feasibility and alignment before development begins.