The open beta of Onofy stays open for a few more days. After that, the doors close and the app heads for the stores. Before it does, I want to tell you what building it taught me — because this project was never only an app. It was a lab. And the main lesson is blunt: vibe coding is suicide if you want to ship a serious product.
What Onofy is, and why I made it
When I was a teenager, in middle school, I had a lot of lucid dreams. Vivid ones, the kind an artist’s eye wants to keep. I never wrote a single one down. That regret is the seed of the app.
Years later, the technology finally exists to show a dream again — and I had the skills to build the place I wished for back then. Onofy is a dream journal you write or dictate as you wake. Each dream can become a Vision: a few seconds of video made from its words. An Oracle reads your dreams with you. And the people who dreamt the same thing can find each other.
The slogan says it in three words: Dream. Share. Find your people.
A lab disguised as an app
Onofy is a complete product: server, mobile client, payments, moderation, video generation, deployment. I built it with LLM agents writing most of the code, and I used it as a lab to answer one question: what does it take to keep an AI-written codebase reliable as it grows? Here is where it stands today:
2,977
commits since June 12, 2025
~300k
lines of code: Rust 120k, TypeScript 115k, Python 38k, shell 19k, SQL 13k
20+
guardrails on every commit and in CI, backed by 50+ control scripts
And the same method now holds up on another project I run in parallel — more than 4 million lines of code. I can work in it without cold feet. That is not because the AI got smarter. It is because I stopped trusting it.
Vibe coding is suicide for a real product
Let me be fair first: you can one-shot working things with an LLM today. A screen, a feature, a prototype — done in minutes. The problem starts on day 30, when the codebase is big enough that no single session sees all of it. Then the agent starts to rewrite what already exists, to “fix” a bug by hiding it, to leave a TODO behind and call the task done. Every one of these compiles. Every one of them lies.
What does not work
The PRD. Writing a product spec helps, but it is less than 10% of the work. Neither you nor the AI can foresee the problems you will hit. You will compromise, re-evaluate, change your mind when you get stuck. The spec is a starting point, not a map.
Rules in a .md file for the agent. Almost useless. The agent reads them, agrees, and drifts away from them a few hundred lines later.
Describing your method. Same fate. “Always search before you write a new function” is a sentence. A sentence protects nothing.
The only thing an LLM respects: a physical constraint
I learned this on another project: a harness that drives Blender like a human would. There, security is everything. And the conclusion was humbling: if you want an LLM to follow the safety rules, the first step is to not trust it at all. You put blockers in its way. You design a system it cannot get around by construction — not by goodwill.
If you want an LLM to follow the rules, the first step is to not trust it at all.
It is a bit depressing, but on large projects it is the only thing that is reliable. So I applied the same idea to every non-negotiable part of the project. Instead of writing a rule in a .md, check live that it is followed. The two places I found for that: a git hook and CI. Git is the front door; the check sits on the door. It does not matter who wrote the code — Claude, DeepSeek, another harness, or me by hand.
Example: the anti-slop hook
One global pre-commit hook runs in every repository on my machine (git config --global core.hooksPath). It refuses five things, with no exception:
- Stubs —
TODO,FIXME,NotImplementedError,todo!(), “for now”. Work announced and not done. - Silenced tools —
@ts-ignore,eslint-disable,#[allow(dead_code)],# noqa. The compiler was shouting; someone made it shut up. - Fake services —
mock,fake,dummy, a hard-codedlocalhostor a dummy key, outside test files. - Dead code — a new function that nothing calls.
- Duplication — the most chaotic habit of LLMs: they write a second, slightly different version of a function that already exists.
For duplicates, the engine is jscpd (a Node tool that finds copy-paste across Rust, TypeScript, Python and shell), with a small Python filter that ignores blocks made only of imports. The threshold is zero: any clone blocks the commit.
jscpd "$REPO" \
--min-lines 10 \
--min-tokens 80 \
--skip-comments \
--threshold 0
The rest is plain Python, standard library only: ast to find functions nobody calls, and tokenize to split each line into code, strings and comments. That split matters: TODO at the start of a comment is a confession, but the word inside a string (“show the TODO list”) is just a word. A guardrail that cries wolf gets bypassed; a precise one gets respected.
One more detail: the hook judges the whole repository on every commit, not just the diff. The past blocks like the new. A repo that is not at zero does not commit until it is cleaned.
What happened the first time I turned it on: about 700 violations. It took me two days to clean them all. Then the project got a real boost: for the first time in months, I could move forward with confidence instead of wondering what the last session had quietly broken.
A starter hook you can copy
You do not need my 2,700-line script to start. Here is a skeleton that already blocks the worst habits. Save it as .githooks/pre-commit, make it executable (chmod +x), and turn it on once per clone with git config core.hooksPath .githooks.
#!/usr/bin/env bash
# .githooks/pre-commit
# Turn it on once per clone: git config core.hooksPath .githooks
fail=0
# refuse '<regex>' '<why>' -- one line per rule, the whole repo is judged
refuse() {
local hits
hits=$(git grep -nE "$1" -- . ':!.githooks' ':!tests' ':!*.test.*')
if [ -n "$hits" ]; then
printf '\n✗ %s\n%s\n' "$2" "$hits"
fail=1
fi
}
refuse '(#|//) *(TODO|FIXME|HACK)' 'Stub: work announced, not done'
refuse '@ts-ignore|eslint-disable|# *noqa' 'Silenced tool: fix the error instead'
refuse 'NotImplementedError|todo!\(\)' 'A function that lies about what it does'
refuse 'https?://(localhost|127\.0\.0\.1)' 'Hard-coded local address'
# Copy-paste: zero clone allowed, anywhere in the repo
if ! npx --yes jscpd . --min-lines 10 --min-tokens 80 \
--ignore '**/node_modules/**,**/.git/**' --threshold 0; then
fail=1
fi
if [ "$fail" -ne 0 ]; then
printf '\nCommit refused. Fix the code, not the hook.\n'
exit 1
fi
To grow it, add one refuse line per rule: a regular expression, and the reason shown to whoever gets blocked. Every time an agent surprises you with a new bad habit, that habit becomes a line. The only requirement is Node, for npx jscpd. Put the same script in CI, so the rule holds for everyone and not only on your machine.
The rules of a good guardrail
- No exception list. Not even “dated”, not even “to be resolved”. A free pass never gets resolved: it gets forgotten and becomes the norm.
- Install it before the cleanup, not after. It is the guardrail that forces the work to go all the way. If the number of violations scares you, that number is the size of the job, not an excuse.
- It tests itself. Give each check a self-test mode, with cases it must catch and cases it must let through. Otherwise you never know if it still sees anything.
- When it is wrong, fix the check — never
--no-verify.
And the most important one: never hand a check to an LLM. Either the system does it — a hook, CI, a compiler — or you do it, in person. Anything you ask the agent to verify about its own work will, sooner or later, be skipped. Not out of malice: the context fills up, the goal shifts, and “I checked” becomes a sentence like any other.
A reminder is a sentence. A hook is a wall.
Two traps the hook taught me to see
The orphan rule. Someone writes a clean rule in one place. Later sessions copy it by hand instead of calling it. The copies drift. The original dies without anyone noticing. This is not a style issue: it is how a rule that everyone believes is enforced ends up enforced nowhere. Before copying a condition, search if it exists. Before deleting an unused function, ask if it is not the real rule the code forgot to call.
A green report lies. “Done, all tests pass” from an agent means nothing until you see it with your own eyes: a real request, a real screen, a real phone. Compiling is not working.
Small daily tricks
Instructions fade as a session grows: what was clear at the first prompt is buried two hours later. Two things help me every day:
- A cron that reminds the agent of the instructions at regular intervals. Re-injecting the key rules beats hoping they survive in context.
- The
/goalcommand, which keeps the objective in front of the agent until it is reached.
These help. They do not replace the guardrails: a reminder is still a sentence, a hook is a wall.
Where AI is truly great
Rapid prototyping. Exploring every facet of a project in days instead of months. Trying three approaches to a problem before lunch. On Onofy, I tested half a dozen video models, rebuilt a sound library, wrote twenty transactional emails in five languages — things I would never have attempted alone. For discovery, the LLM is a superpower.
But you have to become the expert
To get a product that does not break and stays maintainable, there is only one path that lasts: become an expert in the domain you want to conquer. The good news is that this is now within reach — precisely thanks to LLMs, which are wonderful teachers when you ask them why.
Why must you become the expert yourself? Because working with an LLM today is like changing colleagues at every coding session. Each new one is brilliant, fast, confident — and remembers nothing of yesterday. Left alone, this colleague keeps proposing new ideas, reopens settled decisions, and will eventually derail the project.
So keep a decision log in a .md file — not as rules for the agent, but as your memory. One entry per decision: what was decided, when, and why. And understand every point in it. You are the only one at the table who was there last week. When the new colleague suggests undoing something, you are the one who can say: “No. We tried. Here is why.”
IK3D Lab Take
AI did not make software engineering easy. It made starting easy, and it moved the hard part: from writing code to constraining code. Trust the system, not the model. Write fewer rules and more walls. And learn your craft for real — the AI will happily teach you, as long as you are the one who stays.
The catch? Guardrails cost time up front, and the first run of a strict check on an old codebase is painful. Do it anyway. It is the only reason I can open a repo of more than 4 million lines today without fear.
Want this on your codebase? I help teams that build with AI agents put these guardrails in place: commit hooks, CI checks, a decision log, and the habits that go with them. If your project is growing faster than your trust in it, get in touch.
Want to see the result? The Onofy open beta is still open for a few more days, on iPhone (TestFlight) and Android (Google Play): onofy.app. Write down your dreams this time.
How this article was written: an AI assistant interviewed me, measured the numbers straight from the repository, drafted the text and built the layout, and ran the starter hook before it went on the page. The experience, the opinions and the final word are mine. I reviewed every line.



