Start With Just an Idea¶
You have an idea. You don't write code. You're in exactly the right place to begin — and you won't need a terminal, a repo, or a single command to take the first real step.
This is Rung 0 of the adoption ladder: the no-code ground floor. It exists for one kind of person — you have a project in your head, you can describe what it should do and roughly how, but you don't build software yourself. Most of CompassAlpha's setup pages assume a developer with git and a repo. This page does not. Here you do the part only you can do — shape the idea — and then hand the technical part to someone (or something) that does that part well.
The honest promise of this page
You will not be asked to install anything, create a file, or run a command. By the end you'll have a clear, plain-language plan you own — and two easy ways to hand it off so it actually gets built. No part of this requires you to become technical.
Why a non-technical start even works here¶
A lot of what makes software go wrong early isn't code — it's unclear thinking about what's being built. When the idea is vague, every builder (human or AI) fills the gaps differently, and the result drifts from what you pictured. The single most valuable thing you can do up front is say, clearly and in order, what you want — the vision, the parts, and the rules that matter. That's a thinking task, not a coding task, and it's the foundation CompassAlpha is designed to grow everything else from.
So Rung 0 is real work, not a waiting room: you're producing the thing the whole framework builds on.
Step 1 — Say it in plain words¶
Don't reach for any vocabulary. In a few sentences, answer:
- What are you building, and who is it for? ("A website where readers track the books they own and want to read.")
- What are its main parts? Name them the way you'd say them out loud. ("The list of books. The shelves people sort them into. Signing in.")
- What rules matter to you? Anything you feel strongly about. ("A book can never silently disappear." "Everything in plain English, no clutter.")
That's it. You've just described the vision, the parts, and the rules — which is exactly the raw material CompassAlpha needs.
Step 2 — Shape it into a simple plan¶
Now take that description and lay it out a little more deliberately. There's a gentle, guided walk-through that turns a plain-English story into a simple structure — one short planning sheet per part, plus your list of rules — without requiring you to set anything up:
→ Start from a story walks you through it with a complete worked example. It defines every word the moment it appears, and you do the whole thing by hand, on paper or in a document. (When that page later mentions standing up repos and tiers, that's the developer's job, not yours — you can stop at the plan and come back here to hand it off.)
When you're done you'll have a plan you own: a plain summary of what you're building, the parts it's made of, and the rules that hold across all of them. That plan is yours — you can read it, change it, and explain it, because you wrote it in your own words.
Step 3 — Hand it off (two easy doors)¶
Here's the honest part: standing the project up — creating the repositories, wiring the AI-agent setup — is a technical step, and it's the one part of this you shouldn't have to do yourself. The good news is your plan makes the hand-off clean. Pick whichever door fits you:
If you're working with an AI coding assistant (or plan to), give it your plan and a short kickoff like this — copy, paste, and fill in the blanks:
I have a project plan written in plain words (pasted below). I want to build it
using the CompassAlpha framework (https://busyboy77.github.io/compassAlpha/).
Please set up the project the CompassAlpha way on my behalf — create the repos
and the tier structure, turn each part of my plan into its own planning document,
and write down my rules as the project's Charter. Start gently (the Bootstrap
preset), explain each step to me in plain words, and don't assume I can run
commands myself — tell me exactly what to click or paste when you need me.
Here is my plan:
<paste your plan from Step 2>
The assistant does the technical setup; you stay the decision-maker, in plain language.
If you'll work with a developer, a contractor, or a technical teammate, give them your plan plus this one-line brief:
"Here's the project, described in plain words. I'd like it set up using the CompassAlpha framework — one planning document per part, my rules as the Charter, started on the gentle Bootstrap preset. The framework's setup guide is at busyboy77.github.io/compassAlpha → Getting Started."
They'll recognise everything in your plan — you've handed them a head start, not a riddle.
Either way, the thinking you did at Rung 0 is what makes the build coherent. You didn't skip the important part; you did it first.
When you've climbed off Rung 0¶
Once someone has stood the project up from your plan, the project is on Rung 2 — Bootstrap (or Rung 1 if it's just you and one assistant keeping it light). You don't have to follow the technical detail — but if you're curious how the plan becomes coherent code, codebase coherence tells that story in plain words too.
Remember this¶
- You don't need to code to begin. Rung 0 is describing your idea clearly and shaping it into a plan — a thinking task, not a technical one.
- The plan is yours. You wrote it in plain words, so you can read it, change it, and explain it.
- The hand-off is one easy step, not a cliff — give your plan to an AI assistant (with the kickoff above) or a developer (with the one-line brief).
- Doing the thinking first is the valuable part — it's exactly what keeps what gets built true to what you pictured.