Turn an idea, an AI conversation, or a messy repository into structured, tested, documented software.
Project Bootstrap · Loop Orchestrator · Beginner-friendly · Safe on existing repos
You describe an app to an AI. It gives you code. You add another feature. Something breaks. The files multiply. Tests are optional. Documentation becomes folklore.
Buildloom gives the AI a repeatable engineering process.
It helps Your Agent:
- understand what you are building,
- create the right project documents and repository foundation,
- work in small, testable loops,
- verify changes before claiming success,
- leave a useful trail for the next session.
Tip
You do not need to know how to design a repository, write a PRD, choose test boundaries, or manage an engineering loop. Explain your idea in normal language. Buildloom supplies the structure.
After installing both Skills, paste this into Your Agent:
Use Project Bootstrap and Loop Orchestrator for this project.
I want to build: [describe your idea in plain language]
First, create the project foundation and explain the important decisions simply.
Then define the smallest useful version I can run end to end.
Use test-driven development for behavior.
Work in small build-test-observe-adjust loops.
Preserve a build log, error log, decisions, and next steps.
Do not claim something works unless you verified it.
That is enough to begin.
Buildloom is a public suite of two independent Your Agent Skills.
| Skill | Plain-English job | Use it when |
|---|---|---|
| Project Bootstrap | turns an idea or existing repository into a clear engineering foundation | starting a project, rescuing a messy repo, generating docs, defining the first build slice |
| Loop Orchestrator | guides the AI through bounded plan-test-build-verify cycles | implementing a feature, fixing a bug, refactoring, hardening, or resuming unfinished work |
They install separately because the agent platform accepts one Skill per ZIP. They work best as a pair.
Your idea or repository
│
▼
┌──────────────────────┐
│ Project Bootstrap │
│ scope · docs · plan │
│ structure · tests │
└──────────┬───────────┘
│ first vertical slice
▼
┌──────────────────────┐
│ Loop Orchestrator │
│ understand · test │
│ build · verify │
└──────────┬───────────┘
│ evidence
▼
Working software
Download and install each Skill separately:
project-bootstrap-skill.ziploop-orchestrator-skill.zip- Open your Agent Skills library at
/skills. - Upload one ZIP at a time.
Important
Do not combine both Skills into one upload. The standard Skill upload flow expects one Skill per ZIP.
- An agent platform with Skills support
- Python 3.11 or newer to run the deterministic local scripts
- PyYAML only when you choose YAML configuration for Project Bootstrap
No coding framework is required. Buildloom can inspect common Node.js, Python, Go, and Rust repository signals.
Use this:
Use Project Bootstrap to turn this idea into a new project:
[describe the app, tool, game, automation, or website]
Assume I am new to software development.
Use the standard profile unless a prototype is clearly better.
Create the essential documents, repository structure, working commands,
testing plan, and first end-to-end vertical slice.
Explain technical decisions in plain language.
Then prepare a handoff for Loop Orchestrator.
Project Bootstrap can prefill files such as:
README.md
AGENTS.md
CHANGELOG.md
CONTRIBUTING.md
docs/
├── PRD.md
├── ARCHITECTURE.md
├── BUILD_SPEC.md
├── ROADMAP.md
├── TESTING.md
├── SECURITY.md
├── DECISIONS.md
├── BUILD_LOG.md
├── ERROR_LOG.md
└── ENGINEERING_DIARY.md
You do not need every document for every project. The selected profile controls the paperwork level.
Use this:
Use Project Bootstrap on this existing repository.
Inspect before changing anything.
Treat the current code and verified commands as evidence.
Classify important documents as valid, stale, missing, or conflicting.
Preserve working conventions and valid files.
Preview proposed changes before applying them.
Create missing foundations and patch stale sections conservatively.
Run the repository audit and doctor checks.
Do not invent commands or claim checks passed unless they were executed.
The existing-repository workflow follows:
INSPECT → CLASSIFY → PLAN → PREVIEW → APPLY → VERIFY
Buildloom preserves existing files by default. It does not arrive with a bulldozer labeled “best practices.”
Use this after Project Bootstrap:
Use Loop Orchestrator to implement the next vertical slice.
Mode: feature
Maximum iterations: 8
Use the acceptance criteria from the project documents.
Write or update the failing test before behavioral implementation.
Make the smallest change that moves the objective forward.
Run targeted verification during each iteration.
Run full verification before completion.
Record evidence, failures, decisions, and changed hypotheses.
Stop if the same failure repeats three times.
| Profile | Best for | What it emphasizes |
|---|---|---|
| Prototype | experiments, weekend builds, proof of concept | speed, minimal docs, one runnable flow |
| Standard | serious personal projects and small teams | balanced docs, tests, CI, maintainability |
| Production | public, commercial, or high-risk systems | security, operations, deployment, recovery, deeper quality gates |
For most vibe-coded projects, start with Standard. Prototype is intentionally light. Production is not a decorative badge; it requires real evidence.
Loop Orchestrator uses a bounded state machine:
Understand
↓
Define
↓
Test or validate
↓
Implement the smallest change
↓
Observe the result
↓
Verify
↓
Adjust, complete, or block
Each iteration records:
- one objective,
- one working hypothesis,
- the change made,
- the checks actually executed,
- the observed result,
- the next decision.
This prevents the AI from changing five unrelated things and declaring victory because the page loaded once.
The images below are conceptual product mockups for the Buildloom workflow and future interface direction. The current public release is an Agent Skills suite with bundled command-line tools, not a hosted SaaS application.
Choose a starting mode, documentation profile, and repository layout. Preview the foundation before it is created.
Classify documents as valid, stale, missing, or conflicting. Preserve valid files, patch conservatively, and review conflicts.
Track the current objective, iteration budget, targeted checks, full verification, evidence, and stop conditions.
Buildloom is designed to make AI-assisted coding less reckless.
- Existing files are preserved by default.
- Dry-run and inspection come before existing-repo writes.
- Unknown commands remain unknown instead of being invented.
- Behavioral changes start with a failing or updated test.
- Documentation and configuration changes start with the relevant validator.
- A passing claim requires executed evidence.
- Full verification is required before a loop completes.
- Iteration budgets stop endless retries.
- Repeated identical failures trigger a block instead of more thrashing.
- Commit, push, pull request, merge, and review-resolution actions require explicit authorization.
- Secrets should never be written into generated documents or logs.
Buildloom does not magically prove that a product is secure, scalable, profitable, accessible, or production-ready.
It provides structure, deterministic checks, and disciplined AI workflows. Real production claims still require project-specific testing, review, monitoring, and human judgment.
It also does not replace learning. It gives you a map while you learn where the roads go.
buildloom/
├── assets/images/ # GitHub header and concept previews
├── docs/
│ └── VIBE_CODING_GUIDE.md # slower, beginner-first walkthrough
├── releases/
│ ├── project-bootstrap-skill.zip
│ └── loop-orchestrator-skill.zip
├── skills/
│ ├── project-bootstrap/
│ └── loop-orchestrator/
├── scripts/
│ └── check_release.py
├── CONTRIBUTING.md
├── SECURITY.md
├── CODE_OF_CONDUCT.md
├── CHANGELOG.md
└── LICENSE
Run the complete release check:
python scripts/check_release.pyCurrent automated suite:
| Component | Tests |
|---|---|
| Project Bootstrap | 24 |
| Loop Orchestrator | 10 |
| Total | 34 |
The tests cover core scaffolding, repository auditing, validation, loop state, evidence recording, iteration control, and completion rules. They do not prove every generated project is automatically production-ready.
Read The Vibe Coder's Guide to Buildloom for a slower walkthrough covering:
- what a repository is,
- what the generated Markdown files are for,
- how to start from a raw idea,
- how to rescue an existing AI-generated project,
- what to paste into Your Agent,
- how to understand tests and failures,
- when to stop a loop and ask for help.
Read CONTRIBUTING.md. New behavior needs regression tests. Documentation claims must match what the scripts and tests actually prove.
Beginner feedback is especially valuable. If a step assumes knowledge you do not have, that is a documentation bug.
MIT © 2026 Ryan Dabao
Buildloom · From vague idea to verified build.