Skillget

shipwright

agent
Guvenlik Denetimi
Uyari
Health Uyari
  • No license — Repository has no license file
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 8 GitHub stars
Code Gecti
  • Code scan — Scanned 5 files during light audit, no dangerous patterns found
Permissions Gecti
  • Permissions — No dangerous permissions requested
Purpose
This tool is a multi-agent orchestration system that uses Claude Code and a deterministic graph engine to build and deploy production applications. It automates a 12-phase pipeline ranging from initial requirements gathering to final QA and deployment.

Security Assessment
Overall Risk: Medium. The light code audit of 5 files found no dangerous patterns, hardcoded secrets, or dangerous permission requests. However, the tool's core functionality relies on executing shell commands, generating code, and interacting with external services. The README explicitly recommends using `--dangerously-skip-permissions`, which broadly disables Claude Code's built-in safety guardrails. While the scanned files are currently safe, this flag introduces a high risk of unintended local actions, such as arbitrary file modification or unauthorized network requests, during the automated 12-phase pipeline.

Quality Assessment
The project is actively maintained, with its most recent push occurring today. Quality and community trust are currently low. It has only 8 GitHub stars, indicating minimal community vetting or real-world testing. Furthermore, the repository lacks a license file, meaning there are no explicit terms for how the code can be legally used, modified, or distributed.

Verdict
Use with caution. The current codebase is safe, but combining an untested, unlicensed tool with commands that bypass standard safety permissions introduces significant operational risk.
SUMMARY

Multi-agent orchestration for building production apps with Claude Code. 15 agents, 12-phase pipeline, from requirements to deployed.

README.md

Shipwright

Multi-agent orchestration for building production apps with Claude Code

Stars License TypeScript X

You describe what you want to build. Shipwright orchestrates 15 specialized AI agents through a 12-phase pipeline, from requirements to deployed and QA-tested.

Quick Start

gh repo create my-app --template aster2709/shipwright --clone --private
cd my-app

Option A: acpx (recommended — deterministic)

The graph engine drives every phase. No skipping, no idle agents, automatic retries.

# Edit your requirement
nano .acpx-flows/build-input.json

# Run the pipeline
acpx flow run .acpx-flows/build.flow.ts --input-file .acpx-flows/build-input.json

Option B: Claude Code Skills (flexible, human-in-the-loop)

claude --dangerously-skip-permissions
# Then: /build a SaaS invoice platform with Stripe integration

How It Works

Requirements → Research → Architecture → Design → Skeleton
  (gate)                    (gate)
                                                      ↓
Implementation Planning → Backend + Frontend (parallel)
      (gate)                        ↓
                              Testing → Review → Audit → Deploy → QA

LLMs used as orchestrators idle between phases, skip steps, and forget to check on teammates. Shipwright pairs a deterministic graph engine (acpx) with Claude Code as the agent runtime. The graph handles scheduling, retries, and branching. The LLM handles reasoning and coding.

Agents (15)

Agent Role
team-lead Orchestrates pipeline, enforces completion, never idles
requirements-analyst Clarifying questions, PRD with budget/deployment constraints
researcher Best practices, cost analysis, technology recommendations
architect System design, API contracts, data model, cost estimates
ui-designer Design system, shadcn/ui + Magic UI scaffolding via 21st.dev
skeleton-builder Repo structure, configs, empty modules that compile
implementation-planner Task breakdown with dependencies and file ownership
backend-implementer API routes, database, integrations, business logic
frontend-implementer Pages, components, styling per DESIGN.md spec
test-engineer Unit, integration, component tests
reviewer Security, performance, correctness review
auditor PRD coverage verification, gap analysis
deployer Platform deployment, env config, cost-aware
monitor Post-deploy health checks, CI/CD verification
qa-tester Deep code audit, traces flows end-to-end, finds what breaks

Execution Modes

Mode Engine Completion Best for
acpx flow Graph engine (deterministic) Guaranteed — all nodes must complete Production builds, reliability
/build skill LLM orchestrator (Agent Teams) Best-effort — LLM may idle or skip Exploratory work, flexibility
/feature skill LLM orchestrator (Agent Teams) Best-effort Quick feature additions

Skills

Skill When
/build New app from scratch — full 12-phase pipeline
/feature Add features to an existing codebase — 8 phases
/audit Gap check against PRD anytime

Agent Communication

  1. Direct messaging — teammates talk to each other for questions and handoffs
  2. Shared task list — work items with dependencies and status tracking
  3. docs/ folder — formal outputs that become the project's source of truth

The team lead is the heartbeat — actively checks progress, spawns next phases immediately, never waits passively.

Documentation

Agents produce these artifacts in docs/:

File Producer Contents
PRD.md requirements-analyst Product requirements, user stories, constraints
RESEARCH.md researcher Technology recommendations with cost analysis
ARCHITECTURE.md architect System design, API contracts, deployment plan
DESIGN.md ui-designer Visual design system, component library choices
IMPLEMENTATION_PLAN.md implementation-planner Tasks with dependencies and file ownership
QA-REPORT.md qa-tester Browser test results with screenshots

Architecture

cmux / tmux                          (observe agents in split panes)
  └── acpx                           (deterministic graph engine — schedules phases)
       └── Claude Code               (agent runtime — executes each node)
            ├── 15 agent definitions  (each owns one phase)
            ├── docs/                 (inter-agent communication via artifacts)
            └── Honcho               (persistent memory across projects)

Self-Improvement

After successful builds, reusable patterns are saved to .claude/skills/learnings/. Future builds reference these to avoid rediscovering the same solutions. The more you build, the better it gets.

Requirements

  • Claude Code with Claude Max plan
  • acpx (npm install -g acpx@latest) — deterministic graph execution

Recommended

  • cmux or tmux — split-pane agent visibility
  • Honcho plugin — persistent memory across projects
  • 21st.dev Magic components — UI design inspiration

License

MIT

Yorumlar (0)

Sonuc bulunamadi