Questy
HTML demo

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.

30 · perspectives — choosing which hat and how to ask 20 · regenerate — producing the next question batch 30 · replies — folding answers back into the docs 12 · links — referencing & consulting 8 · workflow — practical chores

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.

40 · addon setup — the recommended set, one addon at a time 30 · doing — living the workflow for real 15 · links — referencing & consulting 15 · answering — feeding 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.

### Chapter 1 · the survey is already made

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:

- Project: flove · `flove.org/development`
- Survey batches: 50 questions · 5 per hat · batches of 3 · grouped per perspective
- Perspectives: all six hats selected — facts, heart, risk, optimism, creative, make
- Selections: tone human · focus deep · the recommended addons already lit

Everything below begins with the single remaining action: clicking Recommended.

### The 100 steps of a questy1 run

20 · setup — the click and the tree 10 · perspectives — hats and the doc scan 23 · generate — batches and the new set of questions 27 · replies — answers folded back into the docs 15 · links — referencing the standards 5 · workflow — git, report, continue

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.

### The recommended stack

Clicking Recommended selects exactly these addons — the ones marked (1) in the skill, plus the scripts and outputs that make the bundle self-sufficient:

- tree — standards/, plans/, questy-docs/ + questy-pending.md, conflicts.md, proposals.md
- index — README.md/INDEX.md mapping the structure (wiki when the project ships docs)
- agents — agents.md with shortcuts, constraints, pending-resolutions
- git — detect the repo, .gitignore, stage created files
- archive — archive.md; resolved items retire there
- scripts — build, test, lint, format (the recommended skeleton)
- synced workflow — commit after each creation
- output — export-md + wiki (docsify)

### The real prompt and its price

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* | — | —

est. cost per run (Sonnet-class, USD)
questy1 recommended
—
default survey
—

*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.

### What the tree looks like after

    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.

est. cost per run (Sonnet-class, USD)
full setup
$0.60
questy1
$0.17
default survey
$0.06
survey + update
$0.12
wall time (minutes)
full setup
~25
questy1
~5
default survey
~5
survey + update
~9
output tokens per run
full setup
~40k
questy1
~11k
default survey
~4k
survey + update
~8k

### Where the cost actually goes

Full setup is not 3× the intelligence — it's 3× the surface area.

- Serialization. Every one of ~20 files is a tool call with a full path, a full payload, and a confirmation echo — each one doubles as output tokens.
- Context refills. Long single runs hit the context ceiling; the agent re-reads the skill spec and the tree to stay coherent, burning input tokens on repeat.
- Retries. ~28 tool calls mean ~5–10% will be rejected or malformed and retried — silent extra cost.
- Fixed overhead. The 1.4k-token prompt, the wiki fetch, and the initial spec read are paid once — they amortise well over a full setup, badly over a 5-minute survey.

### The deep read

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.

S1 · E1
The Copy

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?

S1 · E2
The Paste

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?

S1 · E3
Permission Denied

"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?

S1 · E4
The Loop

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?

S1 · E5
The Permission

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?

📖 wiki — UseCase-adv.md (development) →

Copy the prompt above and paste it into your agent's chat (Claude, Cursor, etc.). The agent will:

1. Fetch the questy skill from `flove.org/development/standards/skills/questy/SKILL.md`
2. Set up your project structure based on your selections

You can Download it as a `.md` file to save locally, or JSON to reuse these settings later.

Tip: Run this form again anytime to tweak your config — the agent will re-apply changes.

Survey
questions grouped per
categories:
per time
Tone(s):
Focus:
ⓘ Flove:

For a more flove-focused experience go to questy-flove/index.

##
Thinking Hats

for
explainers
formalise
teleology
field
time span
additional perspectives settings
Index — generates a README.md or INDEX.md mapping your folder structure and each file's purpose. Agent: scan the tree and write one line per folder/file; when the project ships docs, prefer the wiki output so index + docs live together (as does flove.org/development).
Agents.md — creates agents.md with your preferences — shortcuts, constraints, pending-resolutions, territory, aliases. Agent: fill from the agents.md options selected below; the file is read on every session start.
Tree — creates project folder structure: questy-docs/, plans/, standards/, questy-pending.md, conflicts.md, proposals.md. Agent: create any missing folder/file under the project root; keep standards/ frozen, plans/ active, questy-docs/ as reference.
Git — detects the local git repo, adds .gitignore (unless the synced workflow is on), syncs new files. Agent: run git status, create .gitignore, stage created files.
.github/ — adds .github/ with issue templates, PR templates, and workflows. Agent: create .github/ with an issue template, a PR template, and a workflow file.
See demo →
HTML — renders your survey as an interactive web form via the questy-html skill (flove.org/…/questy-html): click through the questions, preview live, and share a browser-ready page before exporting. Agent: build the interactive questy-html form page from the survey.
Audio — narrates the session's questions and answers as an MP3 via the narraty skill (flove.org/…/narraty): a short music opener, then the full text read in a chosen voice — offline, Piper TTS, no API keys. Agent: run the narraty task on the Q&A and deliver `audio/questy-intro.mp3`. It also creates summaries of general, addons setup and/or update processes.
Index: Your project's table of contents — so you remember what's where. Agents.md: Your cheat codes — skip setup next time. Tree: Folders that make sense (questy-docs/, plans/, standards/). Git: Tracks your mess so you can undo it. .github: Templates so issues don't suck. HTML: View it in a browser before sharing. Audio: Listen to the session as a narrated MP3.
local route or url
Files to add
archive
Simple: Just mark done. Archive: Put it in the attic. Advanced: The attic with a filing system.
agents.md
Shortcuts: "I already told you this." Constraints: "Don't touch my stuff." Pending: The stuff we're avoiding. Batch: Ask more about X, less about Y. Export: Save it before it's gone. Territory: Where things live. Aliases: Same thing, different word. Risk: What keeps you up at night. Decision log: Why we did the thing.
templates
React App: A ready website skeleton. Node.js API: A server that other apps talk to. Python Package: A reusable library. Minitree: A small self-contained project. CLI Tool: A command you run in the terminal. Documentation: A nice manual for your project.
workflows
Synced: New files go straight to git. Merge rules: PRs that don't make reviewers cry. Commit guard: Catches typos before they ship. Finish line: "Am I done?" checklist. Blueprint: Plan work without the meeting. Blogy: Writes the blog post for your Hugo · Gitea · Pages site.
Story: Readable summary. Data dump: Machine-readable. Spreadsheet: For the Excel people. Notion: Lives in your wiki. Obsidian: Lives in your brain. Wiki: Sets up a docsify docs site for your project's git pages.
Tickets: Questions become tasks. Jira: Same but for Jira people. Linear: Same but for Linear people. Slack: Ping when done. Pulse: Tell your robot.
PR standards questions
PR title format
Description template
Review checklist
Merge rules
Branch naming
Commit message format
Scripts to add
additional settings
prompt preview

Copy the prompt above and paste it into your agent's chat (Claude, Cursor, etc.). The agent will:

1. Fetch the questy skill from `flove.org/development/standards/skills/questy/SKILL.md`
2. Set up your project structure based on your selections

You can Download it as a `.md` file to save locally, or JSON to reuse these settings later.

Tip: Run this form again anytime to tweak your config — the agent will re-apply changes.