Tech Stack Orchestrator

A meta-skill for orchestrating the complete Claude Code component ecosystem. Analyze projects, recommend components, create custom tools, and evaluate effectiveness before building.

Component Taxonomy

Claude Code supports 6 component types, each serving distinct purposes:

Type	Icon	Purpose	Location	Trigger
Agent	🤖	Specialized AI personas with domain expertise	`.claude/agents/`	`/agent:name` or auto-detection
Command	⚡	Slash commands for quick actions	`.claude/commands/`	`/command-name`
Setting	⚙️	Configuration presets	`.claude/settings.json`	Auto-applied
Hook	🪝	Event-triggered automation	`.claude/hooks/`	Pre/post tool events
MCP	🔌	External service integrations	`.claude/mcp.json`	Tool availability
Skill	🎨	Complex capability packages	`.claude/skills/`	Context-triggered

Orchestration Workflow

Phase 1: Project Analysis

When analyzing a project for tech stack recommendations:

1. GATHER: Collect project context
   - What type of project? (web app, CLI, API, mobile, etc.)
   - What technologies? (React, Python, Node, etc.)
   - What workflows? (git, CI/CD, testing, etc.)
   - What integrations? (databases, APIs, services)
   - Team size and experience level?

2. IDENTIFY: Determine needs by category
   - Development personas needed (agents)
   - Repetitive actions to automate (commands)
   - Environment configurations (settings)
   - Event-driven automations (hooks)
   - External service connections (MCPs)
   - Complex capability packages (skills)

3. MATCH: Map needs to existing components
   - Reference the component library (see references/component-library.md)
   - Identify gaps requiring custom components
   - Note synergies between components

Phase 2: Stack Recommendation

Provide structured recommendations with effectiveness analysis:

## Recommended Tech Stack for [Project Name]

### 🤖 Agents (n selected)
| Component | Why | Synergies |
|-----------|-----|-----------|
| [name] | [reasoning] | Works with [x, y] |

### ⚡ Commands (n selected)
...

### ⚙️ Settings (n selected)
...

### 🪝 Hooks (n selected)
...

### 🔌 MCPs (n selected)
...

### 🎨 Skills (n selected)
...

### Effectiveness Score: X/10
- Coverage: How well does this stack cover project needs?
- Synergy: How well do components work together?
- Efficiency: Are there redundancies or gaps?

### Installation Command
\`\`\`bash
npx organized-ai install [component-list]
\`\`\`

Phase 3: Custom Component Creation

When existing components don't meet needs, create custom ones.

Creating Custom Components

🤖 Creating Agents

Agents are specialized AI personas with domain expertise.

File Structure:

.claude/agents/
└── agent-name.md

Agent Template:

---
name: agent-name
description: When to invoke this agent and what it specializes in
---

# Agent Name

## Role
[Define the persona and expertise]

## Responsibilities
- [Key responsibility 1]
- [Key responsibility 2]

## Guidelines
- [How the agent should behave]
- [What it should prioritize]

## Tools & Patterns
- [Preferred tools and workflows]

Best Practices:

Use PROACTIVELY in description to indicate auto-invocation
Keep focused on single domain
Include concrete examples of when to activate

⚡ Creating Commands

Commands are slash-triggered actions for repetitive tasks.

File Structure:

.claude/commands/
└── command-name.md

Command Template:

---
name: command-name
description: What this command does when invoked
---

# Command: /command-name

## Purpose
[What problem this solves]

## Usage
\`\`\`
/command-name [arguments]
\`\`\`

## Behavior
1. [Step 1]
2. [Step 2]
3. [Step 3]

## Examples
- `/command-name file.ts` - [result]

Best Practices:

Name should be action-oriented (verb-noun)
Keep commands focused on single task
Include clear argument documentation

⚙️ Creating Settings

Settings configure Claude Code behavior.

File Structure:

.claude/settings.json

Settings Template:

{
  "permissions": {
    "allow": ["npm test", "npm run build"],
    "deny": ["rm -rf"]
  },
  "preferences": {
    "autoCommit": false,
    "lintOnSave": true
  },
  "environment": {
    "terminal": "zsh",
    "editor": "vscode"
  }
}

Common Settings Categories:

permissions: Allow/deny bash commands
mcp: MCP server configurations
statusline: Custom status line display
telemetry: Usage tracking preferences

🪝 Creating Hooks

Hooks are event-triggered automations.

File Structure:

.claude/hooks/
└── hook-name.md

Hook Template:

---
name: hook-name
description: What this hook does and when it triggers
trigger: [PreToolUse|PostToolUse|PreMessage|PostMessage]
tools: [Edit|Write|Bash|*]  # Which tools trigger this
---

# Hook: hook-name

## Trigger Conditions
- Event: [when this fires]
- Filter: [which operations]

## Behavior
[What the hook does]

## Implementation
\`\`\`bash
#!/bin/bash
# Hook script
[commands]
\`\`\`

Trigger Types:

Trigger	When
`PreToolUse`	Before a tool executes
`PostToolUse`	After a tool completes
`PreMessage`	Before Claude responds
`PostMessage`	After Claude responds

🔌 Creating MCPs

MCPs connect Claude to external services.

For detailed MCP creation, load: references/mcp-creation-guide.md

Quick Reference - MCP Structure:

mcp-name/
├── package.json
├── src/
│   └── index.ts
└── README.md

MCP Configuration:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "package-name"],
      "env": {
        "API_KEY": "${API_KEY}"
      }
    }
  }
}

Key Considerations:

Use TypeScript with Zod for type safety
Implement proper error handling with actionable messages
Support pagination for list operations
Include tool annotations (readOnly, destructive, idempotent)

🎨 Creating Skills

Skills are complex capability packages.

For detailed skill creation, load: references/skill-creation-guide.md

Quick Reference - Skill Structure:

skill-name/
├── SKILL.md (required)
├── scripts/     (optional - executable code)
├── references/  (optional - documentation)
└── assets/      (optional - templates, images)

SKILL.md Template:

---
name: skill-name
description: Comprehensive description of what this skill does and when to use it. Include trigger phrases and contexts.
---

# Skill Name

## Overview
[What this skill enables]

## Workflow
1. [Step 1]
2. [Step 2]

## Resources
- scripts/tool.py - [purpose]
- references/guide.md - [when to load]

Effectiveness Analysis

Before finalizing a tech stack, evaluate it:

Coverage Matrix

Project Need          | Component          | Coverage
---------------------|--------------------|---------
[need 1]             | [component]        | ✅/⚠️/❌
[need 2]             | [component]        | ✅/⚠️/❌

Synergy Analysis

Identify component pairs that enhance each other:

Agent + Hook: Agent triggers hook for automation
Command + Setting: Command uses setting configurations
MCP + Skill: Skill leverages MCP for external data

Gap Analysis

Identify what's missing:

Uncovered needs requiring custom components
Over-coverage where multiple components overlap
Integration points that need bridging

Scoring Rubric

Score	Coverage	Synergy	Efficiency
10	100% needs met	All components synergize	No redundancy
7-9	80%+ needs met	Most synergize	Minor overlap
4-6	50%+ needs met	Some synergy	Notable gaps
1-3	<50% needs met	Little synergy	Major issues

Quick Commands

Analyze Project

Analyze this project and recommend a tech stack:
- Project type: [type]
- Technologies: [list]
- Key workflows: [list]

Create Component

Create a [agent|command|setting|hook|mcp|skill] for:
- Purpose: [what it does]
- Trigger: [when it activates]
- Behavior: [how it works]

Generate Installation

Generate installation command for:
- [component 1]
- [component 2]
- ...

Reference Files

Load these as needed:

Component Library: references/component-library.md - All 529+ available components
Skill Creation: references/skill-creation-guide.md - Detailed skill creation
MCP Creation: references/mcp-creation-guide.md - Detailed MCP creation
Synergy Matrix: references/synergy-matrix.md - Component compatibility

Installation

After creating components, install with:

# Single component
npx organized-ai install [type]:[category]/[name]

# Multiple components
npx organized-ai install agent:dev-team/frontend command:git/commit hook:auto/lint-on-save

# From stack file
npx organized-ai install --stack my-stack.json

Packaging Custom Components

Package a Skill

python3 /mnt/skills/examples/skill-creator/scripts/package_skill.py <skill-folder> /mnt/user-data/outputs

Package for Distribution

Create a .skill file that can be uploaded to claude.ai/settings/capabilities.

Provide download link: [Download](computer:///mnt/user-data/outputs/skill-name.skill)

tech-stack-orchestrator

Tech Stack Orchestrator

Component Taxonomy

Orchestration Workflow

Phase 1: Project Analysis

Phase 2: Stack Recommendation

Phase 3: Custom Component Creation

Creating Custom Components

🤖 Creating Agents

⚡ Creating Commands

⚙️ Creating Settings

🪝 Creating Hooks

🔌 Creating MCPs

🎨 Creating Skills

Effectiveness Analysis

Coverage Matrix

Synergy Analysis

Gap Analysis

Scoring Rubric

Quick Commands

Analyze Project

Create Component

Generate Installation

Reference Files

Installation

Packaging Custom Components

Package a Skill

Package for Distribution