How it works
Talk it out. Publish something you can stand behind.
Say what you think, or paste what you wrote. A small team of AI agents tidies it into a clear, well-made post that keeps your words, shows what changed and why, and names its sources. Nothing goes live until you say so.
The pitch
The whole idea in one minute
A real one
What was written, and what was published
As it was typed, untouched
We tend to hide ai assisted work like a cheating behaviour rather than a enhanced way of producing results
I want my product to look more human more unique and non slop product
What we reward? What’s the job goal must change
The message it became
And what was left out, in its own words
I cut the repeated circling on "what we reward" and the social media and call centre comparison, and kept the landing: think first, keep your identity, humans decide. The last lines about the Kurzweil book and the prompt reply are garbled and stop without the reply, so I left them out and did not finish them. The interview is unanswered, so nothing here comes from outside the note.
What changes
Say more, type less, and show your working
Writing it yourself
- The idea arrives on a walk and is gone by the time you sit down.
- A blank page, an evening, and a post that sounds like everyone else's.
- Readers can't tell what you said from what a tool added.
- A claim with nothing behind it.
Talking it out here
- A few minutes of talking, a few answers, one read-through.
- A post in your own voice, learned from your own words.
- A switch to the original on every post, and a note on every change.
- Every claim with a source, checked before it goes out.
Your words, kept
The original stays exactly as it came out, one switch away on every post.
Every change has a why
Each file says why it was written that way. Without one, nothing is built.
You press publish
The agents only ever propose. You read it, and you decide.
The tour
From a voice note to a post, in 10 stations
Press Play to hear it, or step through it yourself. Every word the voice says is on screen.
10 stations, under two minutes
Voice made with ElevenLabs. How each clip was made, and with which voice, is written down in docs/audio-sources.md.
Everything underneath
For anyone who wants to check
Nothing here is hidden. Open any part to see the agents, the route a post takes, the files it leaves behind and every service it uses.
The agents13 of them, one job each
Each agent does one thing, reads the blogger's profile first, and writes its why at the top of everything it makes. Two of them can only say no. This list is read from the agents' own instructions every time the site is built.
Phase 1 Ask
interviewA raw note has the feeling and skips the facts.
A raw note has the feeling and skips the facts. This agent does not write anything; it asks the questions a reader would need answered before the thought can be understood by someone who was not there. The questions matter more than the writing, because the context can only come from the blogger, and only while they still remember.
- Reads
origin/*.mdprofile.md- Writes
interview.md
Phase 2 Shape
convertSame core, different shape.
Same core, different shape. This agent writes every version a reader might take in: the short one for a minute, the long one for the road, the post for one social place, the same thought in another language. Each carries the badge and a note on why it was changed that way. None of them pretends to be the origin.
- Reads
structure.mdorigin/*.mdorigin/answers.mdprofile.mdsettings.yml- Writes
versions/short.mdversions/long.mdversions/linkedin.mdversions/<lang>.md
structureA voice note is rarely about one thing.
A voice note is rarely about one thing. This agent finds the point and cuts the note into the shape the site needs: a message a reader gets in three lines, an idea that fits one screen, and the small ideas, each tagged with the themes it belongs to, that the graph is drawn from. It decides shape, never content.
- Reads
origin/transcript.mdorigin/answers.mdinterview.mdprofile.mdsettings.yml- Writes
structure.md
Phase 3 Learn
profileThe profile is the difference between converted and generated.
The profile is the difference between converted and generated. This agent learns how the blogger talks from every origin, and what they accept from every change they make in review, and proposes additions to profile.md as a pull request. It never writes to the profile directly, never infers health, mood or personality, and never adds a line the blogger did not demonstrate in their own words.
- Reads
origin/*.mdorigin/answers.mdgit diff of versions/*.md between the agent's draft and the merged fileprofile.md- Writes
profile.md
Phase 4 Make
citationsEvery claim gets a door out.
Every claim gets a door out. This agent finds what each claim in a post rests on — the book half remembered, the Wikipedia page, the talk on YouTube, the blog, the person's own profile — and turns it into a link where the name appears. An agent can also invent a source, confidently, so nothing it finds is published until the blogger has opened the link.
- Reads
structure.mdversions/long.mdweb search- Writes
sources.md
diagramSome thoughts explain a process or a change, and a reader gets those faster as a picture of boxes than as a paragraph.
Some thoughts explain a process or a change, and a reader gets those faster as a picture of boxes than as a paragraph. This agent finds the few places in the long version where that is true and describes a diagram for each; the site draws it in its own type, in both themes, readable by a screen reader. Most posts need none, and then it makes none.
- Reads
structure.mdversions/long.mdprofile.md- Writes
diagram/diagrams.md
drilldownWhen the blogger mentions a book or a person they care about, the name becomes a link to a short page about it, made once with a deep search, reviewed, and kept in the repo like everything else: a small wiki growing out of the posts.
When the blogger mentions a book or a person they care about, the name becomes a link to a short page about it, made once with a deep search, reviewed, and kept in the repo like everything else: a small wiki growing out of the posts. The pages stay inside the site; the citations agent handles the doors out.
- Reads
sources.mdversions/long.mdwiki/- Writes
wiki/<slug>.md
imageA picture carries the mood, and the mood is what makes someone stop.
A picture carries the mood, and the mood is what makes someone stop. This agent makes one picture per thought in the house style and nothing else: monochrome, lines and dots, the same hand every time, so a post about an art show and a post about a pull request look like they belong to the same person. If it cannot fit the page, it makes nothing; no image is better than the wrong one.
- Reads
structure.mdsettings.yml → media.image_styleprofile.md- Writes
image/prompts.mdimage/NN-<what-it-shows>.png
Phase 5 Check and send
feedbackSometimes the output is fine and still wrong: it went down a road the blogger did not want.
Sometimes the output is fine and still wrong: it went down a road the blogger did not want. Feedback is a voice note about the output, and this agent treats it as an instruction, not a comment. It reworks the piece; and when the same feedback comes three times, it proposes a change to the route itself: the prompt that steered wrong, or the profile line that did. The complaint fixes the post; the pattern of complaints fixes the machine.
- Reads
feedback/*.mdversions/*.mdagents/*/PROMPT.mdprofile.md- Writes
versions/*.mdagents/<name>/PROMPT.mdprofile.md
publishThe last agent before a human.
The last agent before a human. It gathers what the others produced, checks that every file has a why and every version a badge and an origin link, confirms the safety and security verdicts are pass, and opens one pull request with a body a reviewer can read in a minute: what is new, what changed from the origin, and what to look at first. It also prepares the social short with the badge and the link back.
- Reads
structure.mdversions/*.mdsafety.mdsecurity.mdsources.mdimage/road.md- Writes
the pull request bodyversions/linkedin.md (badge line appended)
safetyThis agent never writes a word of the blog.Can stop a post
This agent never writes a word of the blog. It reads everything that is about to leave, in every language, for hate, contempt, or a line that would land on someone as an attack rather than an argument, and holds the post with a written reason until a human has looked. The blogger does not expect to write such things; he does expect to be tired, annoyed, or careless in a language that is not his first.
- Reads
versions/*.mdstructure.md- Writes
safety.md
securityThe second agent that can only say no.Can stop a post
The second agent that can only say no. It keeps the dependencies current, reads the advisories the blogger would never find the time to, and checks everything that leaves for other people's data: a friend's name in a recorded conversation, a face in a photo, an email in a note. None of that leaves the repo until the blogger has confirmed it should, and the rules it checks against are written down.
- Reads
package-lock.jsonnpm audit and GitHub advisoriesversions/*.mdimage/sources.md- Writes
security.mddependency update pull requests
seoPrivate by default, public by decision.
Private by default, public by decision. When the index switch is on, every page should say what it is in the way search tools and AI answer engines read: a clear title, a plain description, structured data that names the author, the date and the language, a sitemap, and the links between versions. Nothing clever, nothing that tricks a crawler; a page a machine reads as easily as the blogger's kids.
- Reads
structure.mdversions/*.mdsettings.yml → publishing.indexthe built site- Writes
seo.mdpull requests to site/ when a page lacks its metadata
The routewho goes when, and who decides
There is no hidden pipeline. Every step is a pull request on GitHub, and each agent is called by a label on it. The route is visible, reversible and written down.
- StudioTalk, or paste what you wrote
- OriginKept exactly as it came out
- InterviewAsks what a stranger would need
- StructureMessage, idea, road
- Five makers, side by sideVersions, drawings, diagrams, sources, wiki
- Two that can say noCan stop the post, in writing
- PublishOne pull request, readable in a minute
- You mergeNothing goes live without you
- Talk backA complaint fixes the post; a pattern fixes the route
- PublishedWith a switch to the original
| You do this | This happens |
|---|---|
| Record or paste in the studio | A pull request opens with your words, unedited, as the origin |
Add the label agent:<name> | That one agent runs on that one thought and commits its files to it |
| An agent holds | Its reason is committed and the check fails, so nothing merges by accident |
| Merge | The post goes live. Nothing else can publish |
| Record a note about the output | The feedback agent reworks only what the note is about |
Why labels, and not an automatic chain
An automatic chain is faster, and harder to trust. With a label per agent, every run is a commit you can read, with the agent's name on it and its why at the top of every file it wrote. If one goes wrong you undo that commit and run it again, without starting over.
The order follows the phases: ask, shape, make, then check and send. The profile agent learns in the background, from your words and from what you change in review; it only ever proposes, as its own pull request. The labels can be added by a schedule later. The last step never changes: a person merges.
The paper trailwhat every post carries
A post is a folder, not just a page. Everything an agent read, wrote or was told is in it, each file with a reason at the top.
- origin/your words, never edited
- structure.mdthe point, cut three ways
- versions/ and image/each version and the print, each with its why
- sources.md and road.mdevery claim’s link; who ran, in what order, told what
- feedback/your notes on the output, which rework the versions
| File | What it proves |
|---|---|
origin/ | What you actually said, before any tidying |
structure.md | What the point was taken to be, and why |
versions/ | Each version, which origin it came from, what changed and why |
sources.md | Where each claim comes from, and that it was checked |
image/ | The drawing and the exact prompt it was drawn from |
road.md | Which agents ran, in which order, with which instructions |
feedback/ | What you asked to change after reading it |
What it usesevery source and service, and where it is written down
Your words are the only facts a post starts from. Everything else it leans on is listed here.
| Source | What it is for | Written down in |
|---|---|---|
| Your voice or text | The thought itself | origin/ |
| Your answers | The context a stranger needs | origin/answers.md |
| Your profile | How you talk; every agent reads it first | profile.md |
| Site settings | Name, languages, themes, the drawing style, the publish switch | settings.yml |
| Claude, by Anthropic | The thinking agents, and a review of every drawing | road.md, settings.yml |
| The web, through Claude's search | A source for each claim, and the wiki pages | sources.md, wiki/ |
| Workers AI, by Cloudflare | Turning the voice note into text | The origin pull request |
| OpenAI's image model | The linocut drawings | image/prompts.md |
| ElevenLabs | The voice on the tour | docs/audio-sources.md |
| Cloudflare | Hosting, the audio store, the studio's sign-in | site/wrangler.toml |
| GitHub | Every pull request and every agent run | The repository's history |
Why it is built this waythe long version
Most of what people think never gets written down. Not because it isn't worth reading, but because writing it properly takes an evening nobody has. Talking takes two minutes. The gap between the two is where this blog lives.
AI can already turn a ramble into a tidy post. The trouble is what you lose: you can't tell any more what the person said and what the machine added, which claims are theirs, and which ones it made up with confidence. A post you can't check is a post you can't trust, however well it reads.
So the rule here is the other way round. The thought is kept first, exactly as it came out, and never edited. Everything after it is a version that points back to it, and every file a version is made of starts with why it was made that way.
The work is split between small agents, one job each, because a small job is easy to check and easy to fix. Each reads the same profile of how the blogger talks, so the post sounds like a person and not like the average of the internet. Every post can be read at three depths: the message in a few lines, the idea on one screen, and the road, with everything behind it.
And at the end there is always a person. When the output goes the wrong way, the blogger says so out loud, and the post is reworked. When the same complaint comes three times, the instructions that caused it are changed. The complaint fixes the post; the pattern of complaints fixes the machine.
Want one for your own thoughts?
The engine is open source. Run it yourself, or get in touch about setting it up for you or your team.