convez.ai
SkillAutomaçãoAvançado
komluk

Claude Scaffolding

komluk/scaffolding

Orquestração multi-agente spec-driven para Claude Code

Ver no GitHub
InicialPluginScore · de 0 a 100

Framework de orquestração multi-agente spec-driven para Claude Code com 11 agentes especializados, 32 skills reutilizáveis e 15 comandos. Funciona como plugin markdown puro sem backend, database ou processos rodando.

Instalação

$npx convez-ai komluk/scaffolding

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
16
Forks
1
Acompanhando
1
Saúde
42%
Último commit
há 4 dias
Versão
v2.41.0
Issues abertas
0
Contribuidores
4

Casos de uso

  • Delegar tarefas entre agentes especializados (arquiteto, desenvolvedor, revisor, debugger)
  • Executar workflows reproducíveis baseados em specs OpenSpec
  • Criar e estender skills customizados com scaffolding automático
  • Aplicar guardrails e hooks de segurança em pipelines de desenvolvimento

Veredito

Framework robusto e bem estruturado para times que precisam orquestração multi-agente sofisticada em Claude Code. A abordagem spec-driven e zero-backend é um diferencial, mas requer familiaridade com conceitos de agentes e workflows para aproveitamento máximo.

README

A tradução para o português deste README ainda está na fila.

claude-scaffolding

Version License: MIT Works with Claude Code Agents Skills Commands

Portable Claude Code configuration: 11 agents, 32 skills, 15 commands, 8 hooks, spec-driven workflows. Installs as a Claude Code plugin.

Overview

claude-scaffolding is a portable, markdown-only Claude Code configuration. It provides multi-agent orchestration, a library of reusable skills, guardrail hooks, and spec-driven workflows — everything ships as plain markdown and runs entirely on the Claude Code runtime, with no backend, database, or long-running process required.

Why use this

  • Spec-driven workflows — OpenSpec-style specs keep work grounded and reproducible.
  • 11 specialized agents — analyst, architect, developer, reviewer, debugger, and more, each with a focused role.
  • Parallel multi-agent orchestration — fan out work across agents and coordinate results.
  • Opinionated guardrail hooks — 8 safety and lifecycle hooks block destructive commands and enforce conventions.
  • Extensible & self-improving — /create-skill scaffolds your own scaffolding-compatible skills, and /learn closes the loop by distilling reusable insights from finished conversations.
  • Zero backend required — pure markdown and Claude Code runtime; no database, server, or process to run.

Install

1. /plugin marketplace add komluk/scaffolding
2. /plugin install scaffolding@komluk-scaffolding
3. /reload-plugins                       ← REQUIRED: Claude Code does not hot-reload the agent registry

Optionally, run /init-scaffolding once per project to create .scaffolding/ and copy CLAUDE.md into the repo (see Per-project setup). Then start delegating: Task(subagent_type="scaffolding:developer", prompt="...").

Without /reload-plugins the subagent_type registry is not refreshed after install — Task(subagent_type="scaffolding:developer") will return Agent type not found. Restarting claude works as an alternative.

The installed plugin lives under ~/.claude/plugins/ — primarily in the versioned cache/komluk-scaffolding/ subtree, with marketplaces/komluk-scaffolding/ as the marketplace clone. Default values (pytest, npm test, (project), etc.) are baked in. To override per-project, edit the rendered CLAUDE.md after running /init-scaffolding.

Per-project setup: /init-scaffolding

After the plugin is installed, run /init-scaffolding from the project root. It creates the .scaffolding/ directory structure (agent memory, conversations, worktrees, OpenSpec specs, reports), adds .scaffolding/ to .gitignore, and copies CLAUDE.md + settings.json + hooks/ into the project. Idempotent — safe to re-run; CLAUDE.md and settings.json are always overwritten with the latest plugin version, hook scripts are always copied.

ScenarioRun init?
Solo projectOptional — the plugin's SessionStart hook injects the routing protocol on every session
Team repo (others clone without the plugin)Yes — CLAUDE.md in-repo means the protocol travels with the code
CI / automation reads the repoYes — a committed CLAUDE.md gives reproducible context

Agent memory

Agents share a file-based, 3-tier memory protocol — all plain markdown under .scaffolding/ of the project. Memory is auto-injected into an agent's context when a task starts: shared tier always, agent tier when the agent name is known, conversation tier when a conversation_id is provided. Each file is capped at 200 lines. Read-only agents (architect, reviewer) cannot write memory — they report findings in their output instead. This protocol is the always-on default; an optional cross-device semantic memory backend adds vector recall on top — enable it per device with /memory enable (see Optional backend-dependent features).

TierFileScope
Shared.scaffolding/agent-memory/shared/KNOWLEDGE.mdWhole-project facts, written/read by any agent
Agent.scaffolding/agent-memory/agents/{agent-name}/MEMORY.mdPer-agent domain knowledge
Conversation.scaffolding/conversations/{conversation_id}/agent-memory/context.mdPer-conversation context and handoffs

Common gotchas

Agent type 'developer' not found

  • Forgot /reload-plugins after install, OR used the bare name. Use scaffolding:developer.

"Claude ignores the delegation protocol"

  • Plugin loaded but /reload-plugins was not run after install.

"I installed the plugin, but nothing works in a new session"

  • Restart Claude Code entirely — the plugin cache may be stale. /reload-plugins is faster if a session is already active.

Requirements

What's inside

claude-scaffolding/
├── agents/         11 agents (analyst, architect, coordinator, developer,
│                    debugger, devops, gitops, optimizer,
│                    researcher, reviewer, tech-writer)
├── skills/         32 skills (api-design, error-handling, pattern-recognition,
│                    skill-authoring, spec-*, mui-styling, python-patterns,
│                    testing-strategy, ...)
├── commands/       16 slash commands: 6 top-level (context, create-skill,
│                    init-openspec, init-scaffolding, learn, memory) + 10 in
│                    `commands/specs/` (apply, archive, bulk-archive, continue,
│                    explore, ff, new, onboard, sync, verify) — namespaced
│                    OpenSpec commands
├── hooks/          9 safety + lifecycle hooks (block-destructive-rm,
│                    block-env-write, pre-commit-validation,
│                    session-start-protocol, memory-project-id, ...)
├── templates/      Shared agent reference docs (output-frontmatter schema,
│                    agents/skills overview, responsibility matrix)
├── validators/     Validation scripts (circuit-breaker, validate-agent-output)
├── output-styles/  output-frontmatter definition
├── workflows/      YAML workflow and coordinate definitions
├── CLAUDE.md       Main project prompt
└── settings.json   Hooks + statusline + permissions

Optional backend-dependent features

A few skills have optional features that can use an external backend if one is available — for example, semantic-memory-store can persist embeddings to a vector store, and ui-ux-pro-max can draw on a local dataset. When no such backend is present, these skills degrade gracefully: the agent skips the relevant section rather than crashing, and all core functionality continues to work as pure markdown.

Cross-device semantic memory (/memory)

The semantic-memory-mcp / semantic-memory-store skills can be backed by a self-hosted mem0 service (PostgreSQL + pgvector, with a local LLM and embeddings via Ollama). When enabled, agents persist and recall insights across sessions and devices through semantic_search / semantic_recall / semantic_store, on top of the always-on file-based memory.

It is opt-in and personal:

/memory enable     # wire the backend into Claude Code (user scope) — run once per device
/memory disable    # disconnect this device (stored memories are kept)
/memory status     # show whether it's wired and reachable
  • Off by default. Nothing connects until you run /memory enable. Installing the plugin without a backend simply runs without semantic memory.
  • Token-gated. Auth uses a personal bearer token (MEMORY_MCP_TOKEN); the endpoint defaults to your own backend and is overridable via MEMORY_MCP_URL.
  • Per-project isolation. The memory-project-id SessionStart hook derives a stable project_id from the git remote, so each repository has its own memory namespace, shared across your devices.
  • Graceful fallback. If the backend is unreachable, skills fall back to the file-based .scaffolding/agent-memory/ — agents never block.

Hosting the backend (LXC/VM, Docker compose, Ollama, network egress policy) is outside the plugin; the plugin only consumes the MCP endpoint.

Updating

/plugin update scaffolding@komluk-scaffolding
/reload-plugins

Re-run /init-scaffolding in projects where you want the latest CLAUDE.md and hooks copied in.

Documentation

Versioning

The project follows SemVer 2.0.0.

BumpWhen
MAJOR (X.0.0)Breaking changes: removing an agent/skill/command, incompatible plugin.json schema changes, install path changes
MINOR (x.Y.0)New agent/skill/command/hook, new feature in CI (backward compatible)
PATCH (x.y.Z)Bug fix, typo, documentation tweaks

Source of truth for the version: .claude-plugin/plugin.json (version field). The git tag MUST match (v${version}) — enforced by release.yml in GitHub Actions.

Version history: CHANGELOG.md.

License

MIT — see LICENSE.

Ver o original no GitHub

Bom para

Relacionados