Automation & AI

/projects/claude-superpack

Claude Superpack

33 specialized skills
87% lower token usage per review
Zero external dependencies

project.claude-superpack.local

Problem: Claude Code starts from scratch every time, losing context, reinventing wheels, and requiring constant hand-holding for complex tasks.

Solution: Built a 33-skill agentic orchestration system for Claude Code featuring persistent memory, blast-radius-aware codebase graphs, parallel worker coordination, and self-improving behavior.

Impact: Transformed a single-shot assistant into an autonomous, stateful agent that safely orchestrates complex tasks with zero external dependencies.

Overview

Claude Superpack transforms Claude Code from a single-shot assistant into a persistent, self-improving agent that remembers across sessions, maps your codebase structurally, scans for security issues, and orchestrates complex tasks across parallel workers.

Before / after

Task Execution

Before: Manual step-by-step sequential guidance

After: Autonomous multi-agent parallel orchestration

Context Awareness

Before: Started entirely fresh every session

After: Persistent memory and preferences across sessions

Stack

Node.js & Bash

Agentic Orchestration

Markdown Memory System

File-based JSON Knowledge Graphs

Decisions

Key trade-offs and design calls that shaped the final delivery.

Zero external dependencies

Context: Adding databases like SQLite or ChromaDB creates friction for local agent workflows

Decision: Used pure markdown for memory and JSON for graphs, enabling instant adoption without complex installation requirements

Token compaction protocol

Context: Large codebases quickly exhaust the LLM context budget during complex tasks

Decision: Implemented running estimates with an active compaction protocol where structured summaries replace raw data after each phase

Architecture

The primary system boundaries, runtime pieces, and how the project was structured in production.

Task Decomposer & Workers

Agentic Orchestration

Routes requests intelligently. Complex tasks are decomposed into DAGs and executed by parallel agents orchestrated through safe-summon.

Markdown Storage

Persistent Memory

Zero-dependency memory system using local Markdown files for recent sessions, long-term patterns, and project context.

Graph Builder

Knowledge Graph

Structural codebase mapping using Glob/Grep/Read. Allows blast-radius-aware code reviews saving up to 87% token usage.

Mermaid source. Paste into mermaid.live to visualize the diagram.

flowchart TD
  U[User Request] --> R[auto-router]
  R --> |Direct| D[direct answer]
  R --> |Orchestrate| O[parallel-orchestrator]
  O --> W1[Worker 1]
  O --> W2[Worker 2]
  W1 --> M[merge-coordinator]
  W2 --> M
  M --> P[post-review]

Pipeline

How changes moved from development through validation and deployment.

Analyze

auto-router

Classifies complexity and routes to the appropriate execution tier

Map

graph-builder

Constructs structural map of codebase lazily over time

Execute

parallel-orchestrator

Spawns isolated workers for decoupled parallel tasks

Verify

security-scanner

Checks for OWASP top 10 patterns and hardcoded secrets before commit

Incidents

Operational failures, rehearsals, or recovery moments that changed how the system was run.

Context budget exhaustion on large codebase reviews

Resolution: Implemented graph-aware smart discovery and blast-radius filtering, dropping token usage by ~87%

Lesson: Blindly sending raw code to LLMs scales poorly—pre-process and map dependencies to only pass relevant file slices

Agents getting stuck in conflicting execution loops

Resolution: Built a conflict-detector to map write surfaces beforehand and orchestrate workers sequentially if overlap is detected

Lesson: Parallel AI workers need strict concurrency boundries and conflict detection to avoid un-mergeable chaos