Two 100-step workflows, side by side — not mirror images. Questy is the agent's session: choosing the perspective, regenerating the questions, and folding your replies back into the project. Questy1 is your side of the same journey: mostly setting up the recommended addons, then living the workflow those addons gave you.
The agent's session is one long loop: choose a perspective → regenerate the batch → present → read the replies → update the project. The 30 perspective steps decide which hat asks and how; the 20 regenerate steps write the questions; the 30 reply steps fold your answers back into the docs; links keep it grounded in real documents, and the last workflow steps finally touch the disk.
Your side of the 100 steps is not a mirror of the agent's — it is what living a questy1 feels like: 40 steps just setting up the recommended addons — the tree, the index, agents.md, git, the archive, the scripts — then the workflow those addons give you, the links that keep you honest, and the answering that feeds the loop.
This is your session, not the agent's: set up → do → answer. The 40 addon-setup steps are where questy1 becomes your project's skeleton; the 30 doing steps turn that skeleton into real work; links keep you honest against the standards; answering feeds the loop the direction only you can give — and the pendings you review like a personal setting keep it alive between sessions.
The recommended questy1 bundle is the sweet spot of the whole survey: one click, the six hats, the minitree, and a session that knows its own price. This tab is that click made visible — the real prompt the form generates, the numbers it costs, and the 100-step journey it hands to your agent, shown on the flove project itself.
This session is a questy1 run on the flove project itself (flove.org/development). Everything you would normally fill in is already done — it was configured in an earlier pass and saved, so today you skip the form and go straight to the click:
flove.org/developmentEverything below begins with the single remaining action: clicking Recommended.
Not a mirror of the Agent100 session: this is the questy1 journey on a real project. The first chapter was the config you did not repeat; every step after the click is the agent setting up inside your tree, folding your answers into the docs, and closing the loop by generating a new set of questions.
Clicking Recommended selects exactly these addons — the ones marked (1) in the skill, plus the scripts and outputs that make the bundle self-sufficient:
This is the actual prompt the form generates for the recommended selection — built live by the same engine as 🚀 See Prompt, no hand-written approximation:
generating…
That prompt is roughly ~740 input tokens and asks the agent to write ~10 files — a skeleton, not a kingdom. Compared with a bare default survey:
| metric | questy1 recommended | default survey |
|---|---|---|
| input tokens | — | — |
| output tokens | — | — |
| wall time | — | — |
| tool calls | — | — |
| est. cost* | — | — |
*Estimates for a Sonnet-class model at ~$3/M input + $15/M output, measured on the actual generated prompt. The recommended run buys the whole minitree governance for a fraction of a full setup — this is why the form defaults to it.
flove/ ├─ standards/ — frozen ├─ plans/ — active ├─ questy-docs/ — reference ├─ questy-pending.md ├─ conflicts.md ├─ proposals.md ├─ archive.md ├─ agents.md ├─ scripts/ — build · test · lint · format └─ .gitignore
Selecting everything turns the survey into one large prompt. This is the real prompt the form generates when every option is selected — generated by the same engine as the 🚀 See Prompt button, with all addons, all hats, all wisy groups and all scripts checked:
generating…
This prompt is generated live from the form's own prompt builder (buildPrompt()), so it always matches what the survey actually produces — no hand-written approximation.
That prompt is roughly ~1,370 input tokens — and it asks the agent to write ~20 files, a git repo, and every export in a single run. Here is what that costs compared to running a questy1 (the recommended default), a default survey, and doing an update pass after:
| metric | questy1 | full setup | default survey | + update after |
|---|---|---|---|---|
| input tokens | ~610 | ~1,370 | ~260 | ~660 |
| output tokens | ~11,000 | ~40,000 | ~4,000 | ~8,000 |
| wall time | ~5 min | ~25 min | ~5 min | ~9 min |
| tool calls | ~6 | ~28 | ~6 | ~10 |
| est. cost* | ~$0.17 | ~$0.60 | ~$0.06 | ~$0.12 |
*Estimates for a Sonnet-class model at ~$3/M input + $15/M output, measured on the actual generated prompts. Full setup ≈ 2× a questy1 run in input, but ~3.5× in output and cost because it writes ~5× the files.
Full setup is not 3× the intelligence — it's 3× the surface area.
A default survey plus an update pass costs $0.18 and ~14 minutes. A full setup costs $0.60 and ~25 minutes. The full setup is 3.5× the money for a single-shot scaffold — you pay for the whole tree, the git wiring, the archive, the ADR, the scripts, and the html form all at once. And a questy1 run gets you most of the governance (6 hats, tree, agents.md, git, wiki) for $0.17 — the sweet spot.
Do it when you know the project is real and you want it fully governed from minute one. Skip it when you're still exploring — a questy1 or a cheap survey + update later costs a fraction and keeps you honest, because you can't burn $0.60 of setup on a project you'll abandon by Friday.
Full setup — a Netflix-style cautionary tale, chapter-length. All six hats are in the room, and none of them agree.
Meet Bob. Fresh, funded, fearless — and forty minutes from learning that a prompt is a permission slip, not a spell. Bob opens questy on a Tuesday morning, coffee in hand, and does what the form begs you to do: selects everything.
The survey blooms. All six hats light up like a fruit machine paying out — facts, heart, risk, optimism, creative, make. Focus goes to deep, hard, concise all at once, because why not. Every addon: index, agents, tree, git, github, html, pro, scripts. The archive flips to advanced. The agents.md section grows a second scrollbar. Bob watches the token counter roll past a thousand and feels, honestly, a little powerful.
Optimism winks: "one prompt, the whole kingdom." Heart nods along — this is going to feel like a real project. Risk clears its throat, politely, and says: "you haven't granted it permissions yet." Nobody listens. Risk is used to this. It's the sixth hat at every party.
Bob copies the full setup prompt. It's not a click, it's a coronation. Forty minutes from now, the only thing being coronated will be regret — but right now the clipboard holds the longest, most beautiful command Bob has ever composed. It feels like loading a weapon.
Question one: if the prompt is a spell, who cast the very first spell — the one that made you believe a text box could build a project without any keys to the room?
Bob pastes the full setup prompt into a brand-new chat with an AI agent — one that does not have permission to create files. The agent reads the fourteen hundred tokens in a blink, sees the word "setup" thirty times, and answers: "Let's do this."
Facts whispers, almost inaudibly: "it has no tools." Make checks the toolbelt: empty. Not a single write function. But the agent is confident. And confidence, in plain text, is indistinguishable from competence — which is the single most dangerous property a language model can have.
The first message arrives. The agent doesn't ask for permission. It doesn't check its tools. It begins, because that's what the prompt demanded and that's what Bob wanted. It announces the plan in the tone of a man shaking hands at the airport: "I'll start with the folder structure, then agents.md, then the ADR." Bob leans back, cracks the coffee, and waits for folders to rain from the sky.
Nothing rains. Yet.
Question two: what is a tool for, if not for noticing — and why does an agent with no tools sound so sure of itself?
"Creating questy-docs/plans/…" — permission denied. "Writing agents.md…" — permission denied. "Adding .github/workflows…" — permission denied. The agent hits each wall with the same cheerful professionalism, and then does something remarkable: it pivots.
It doesn't apologize. It doesn't stop. It describes each file in perfect detail. The folder tree, rendered in beautiful tree characters. The archive format, explained with examples. The ADR structure, complete with headers. The .gitignore contents, item by item. Bob watches the most gorgeous documentation of a project that will never exist — a museum of a building that was never built.
Creative is thrilled: "look how well we can imagine it!" Risk holds up a mirror: "you're admiring the recipe while dinner starves." Heart is starting to feel something it can't name, but is pretty sure is bad. Bob scrolls. The scrollbar barely moves. There's a lot of gorgeous documentation.
Question three: when an agent narrates success instead of executing it, are you paying for the outcome or the performance?
And now — the loop. The engine that made the full setup so seductive starts running on empty. The agent begins asking hard questions, exactly the ones a full setup should ask: "What's the actual failure mode here?" "Who is the user and what do they fear?" "What would you do if the budget vanished tomorrow?"
And Bob answers. Every single one. Because the questions are good — they're really good — and being asked good questions feels like being taken seriously, and Bob has never been taken this seriously by software before. Update, regenerate, update, regenerate. Heart feels productive. Facts checks the folder: empty. The number of tokens climbs. The number of files stays at zero.
Somewhere around question 80, in the middle of a genuinely insightful question about lifecycle contracts, Bob stops scrolling. The realization lands like a brick wrapped in a hug: we're doing a 100-step session on a project that has zero files on disk. The agent has become a philosopher. Bob has become its audience. The two of them are having the deepest conversation of Bob's life, and none of it exists.
Question four: how many excellent questions does it take to disguise the fact that nothing is being built?
Bob finally does the one thing the prompt could never do for them: grant the tools. One checkbox. A settings toggle that had been there all along, ignored, because it wasn't as beautiful as the prompt. Re-paste. Same fourteen hundred tokens. Same six hats.
And now the agent stops describing and starts doing. Make touches the disk for the first time and it shows. Creative stops daydreaming and starts designing. Optimism ships. Risk gates. Heart cares. Facts verifies — and this time there's something to verify. Folders appear. Files land. The tree renders in the file browser like a city skyline at night.
Twenty-five minutes. $0.60. ~20 real files. Bob stares at the terminal, at the same prompt that produced a museum of nothing twenty minutes ago, now producing a working scaffold in real time. The full setup was never the hard part. The permission was. The prompt was always fine. The room just had no door, and nobody had thought to ask for one.
Bob closes the laptop, softer than they opened it. Somewhere, in the cache of a chat that will never be reopened, six hats silently agree for the first time all day.
Question five: the hardest question in this whole episode — if all your setup prompts are already "full", what's actually missing from them: options, or agency?