Claude Code Hackathon Winners

Pattern: Decision Tree Router

Instead of stuffing all 28 legal reference files into context, classify each query first, load only 3-5 relevant files. Four-step routing: Lot type → Construction type → Situational modifiers (transit, coastal, fire, HOA) → Process stage.

Quick-reference thresholds embedded for fast lookup: JADU max 500 sq ft, ADU max 1,200 sq ft, Height 16/18/25 ft by type, Fee exemption ≤750 sq ft.

Pattern: Two-Phase Human-in-the-Loop

Phase 1 (~15 min, ~$3): Agent reads corrections → researches codes → generates questions → PAUSE.

Human step: Contractor answers via frontend form.

Phase 2 (~8 min, ~$3): Agent reads answers → generates response letter + scope + report.

Phase 1 outputs persisted to outputs table. Questions parsed into contractor_answers table with types (text, number, choice, measurement). Phase 2 reads both.

Pattern: Long-Running Agent on Serverless

Pattern: Testing Ladder with Cost Budgets

Haiku/Sonnet for L0-L2, Opus for L3+. Catch $0.01 bugs before $15 runs.

Pattern: Agent SDK Configuration

query({
  options: {
    tools: { type: 'preset', preset: 'claude_code' },
    settingSources: ['project'],
    permissionMode: 'bypassPermissions',
    allowDangerouslySkipPermissions: true,
    allowedTools: ['Skill','Task','Read','Write','Edit',
                   'Bash','Glob','Grep','WebSearch','WebFetch'],
    model: 'claude-opus-4-6',
    maxTurns: 80,
    maxBudgetUsd: 15.00,
  }
});

Gotchas: Skills not found → need settingSources: ['project']. Model init fails → use full alias 'claude-opus-4-6'. Wrong cwd → loads 13 skills instead of 6. Hangs on permissions → need both bypass flags.

Pattern: Spec-Driven Development

The core paradigm flip. Code is a generated artifact, not the artifact itself. Kids specify what they want via blocks. The NuggetSpec is the intermediate representation — structured, validated, machine-readable. Agents translate spec → implementation.

interface NuggetSpec {
  nugget: { goal, description, type }
  requirements: [{ type, description }]
  style?: { visual, personality }
  agents: [{ name, role, persona }]
  deployment: { target, auto_flash }
  workflow: { review_enabled, testing_enabled, human_gates }
  skills?: [{ id, name, prompt, category }]
  devices?: [{ pluginId, instanceId, fields }]
}

Pattern: Parallel Agent Execution (DAG-Scheduled)

while (tasks_remaining) {
  const ready = getReadyTasks()  // no unfinished dependencies
  for (const task of ready) launchTask(task)
  await Promise.race([all_inflight_tasks])
}

Max 3 concurrent agents. DAG validated for cycles using Kahn's topological sort. Each task = one Agent SDK query() call: permissionMode: 'bypassPermissions', model: 'claude-opus-4-6', maxTurns: 25. Agent roles: Builder (writes code), Tester (writes/runs tests), Reviewer (code quality), Custom (user-defined).

Pattern: Context Chain Between Agents

Solves the "agent doesn't know what previous agent did" problem without token waste:

Agent 1 completes → summary written to nugget_context.md → Agent 2 reads context + structural digest (signatures only) → Agent 3 reads updated context.

No re-orientation. No dumping full source. Just summaries + structure.

Pattern: Device Plugin System

New hardware types added by dropping files — no code changes:

devices/{plugin-id}/
├── device.json           # Manifest: board, capabilities, Blockly blocks
├── prompts/
│   └── agent-context.md  # Injected into builder agent prompts
├── templates/            # MicroPython code generation templates
└── lib/                  # Shared libraries flashed alongside user code

Four built-in plugins (ESP32 variants). Deploy ordering respects provides/requires DAG.

Pattern: 8-Layer Context Assembly

Each patient interaction assembles context across structured priority layers:

Every assembly call populates $tokenBreakdown — emitted to frontend via SSE for real-time cost visibility. Typical request: 60K-180K tokens.

Pattern: Prompt Caching (78% Token Savings)

Stable blocks cached with CacheControlEphemeral (5m TTL). System prompts identical across requests. Cache read tokens count at 10% of input. First request creates cache (~10K tokens), subsequent requests read at ~1K tokens.

Pattern: Raw cURL Streaming (SDK Bypass)

Problem: Anthropic PHP SDK uses PSR-18 sendRequest() which buffers entire response. Streaming latency was 8-10s.

Solution: Raw curl_multi_exec with progressive SSE parsing. Yields thinking and text deltas immediately. Result: under 100ms per token. X-Accel-Buffering: no for nginx compatibility.

Pattern: Adaptive Thinking Budget

Regex-based effort classification — no AI needed for routing:

Safety patterns always match first. Regex handles 90%+ correctly.

Pattern: Tool-Use Agentic Loop

3 medical tools available during conversations:

Agentic loop runs up to 5 iterations. Plan-Execute-Verify pipeline validates clinical responses against evidence.

Patterns Worth Noting

Pattern: Agent Specialization

14 agents, each scoped to a domain with specific tools and model preferences:

Key design: Agents fire proactively based on context. Code just written? code-reviewer fires. Build failed? build-error-resolver fires. Opus for thinking, Sonnet for execution.

Pattern: Hook-Based Enforcement (100% vs ~80%)

Rules say "don't push without review." Hooks guarantee it. The core insight: prompts get ~80% compliance. Hooks get 100%.

PreToolUse Hooks (block or warn)

PostToolUse Hooks (react after)

Lifecycle Hooks

All hooks in Node.js (not bash) for cross-platform compatibility. Exit code 2 = block.

Pattern: AgentShield (102-Rule Security Audit)

Purpose-built security framework for AI agent configurations. Different threat model than traditional app security:

Multi-layer defense: Tool permissions → Path restrictions → Sandboxing → Rules + validation.

Pattern: Skills as Knowledge Codex

56+ skills organized as markdown knowledge bases — not executable tools. They provide methodology, patterns, and step-by-step procedures. Categories: coding standards, framework patterns, database, DevOps, business, architecture.

Skills are read-only. They shape how agents think. Version them in git. Review them in PRs. Never hardcode knowledge into agent prompts.

Pattern: Continuous Learning Pipeline

Session ends
    ↓ evaluate-session.js (SessionEnd hook)
Pattern extraction
    ↓
Instincts written to ~/.claude/instincts/
    ↓
Next session loads instincts
    ↓
/evolve command clusters + organizes

Markdown-as-database: All state stored as markdown files. Human-readable, git-trackable, zero dependencies.

Pattern: Multi-Platform Installation

Also available via npm: npx ecc-install typescript python golang