A month in the past, I constructed a full retrieval system with embeddings, hybrid search, and a GUI in about 25 hours. Final weekend, I spent two days making an attempt to repair a bug in it — and realized I had no thought how my very own software program labored.
Let’s be sincere: I’ve pushed a GitHub repo with out having written a single line of code. Do I really feel unhealthy about it? Form of. The quantity of technical doubt weighs closely on my shoulders, far more than I’m used to. Will I remorse it? Possibly. Will you?
I wished to share my story right here as a result of I imagine that is one thing many builders are going via proper now, and much more will expertise it within the coming years.
As a result of let’s face it: you possibly can have a code of honor and be pleased with your craftsmanship, however nothing beats the velocity of GitHub Copilot & Co. In case your colleague on AI steroids ships options and pushes updates twice (wildly underestimated) as quick as you, who do you suppose is nearer to the corporate’s door when budgets tighten?
The productiveness beneficial properties are actual, even when you solely use these instruments for documentation. And there’s a tiny step from:
“Write docstrings for this perform.“
to
“Write the perform.“
That tiny immediate step skyrockets you into a totally completely different realm of productiveness.
However right here comes my very private story, what I realized, and the place I feel this leaves us as builders.
The undertaking: constructing my very own NotebookLM (however stricter)
For background, I got down to construct a RAG-style textual content retrieval system within the spirit of NotebookLM, besides stricter. The system takes a personal PDF library, processes it, after which retrieves solutions verbatim from that corpus. No paraphrasing, no hallucinated sentences, simply “give me the precise passage that solutions my query so I can search it within the unique PDF once more.”
Admittedly, this can be a very scientific, barely paranoid manner of utilizing your literature. However I’m in all probability not the one one who’s bored with fact-checking each LLM response towards the supply.
The structure of the software program was pretty simple:
- A strong ingestion pipeline: strolling listing timber, extracting textual content from PDFs, and normalizing it into paragraphs and overlapping chunks.
- Hybrid Storage & Retrieval: a storage layer combining commonplace SQL tables, an inverted-index full-text search engine (for precise key phrase matches), and a vector database (for semantic understanding).
- A Reranking Technique: some logic to tug a large candidate pool through lexical search, then rerank the outcomes utilizing dense vector similarity to get one of the best of each worlds.
- A Full UI: a dashboard to handle the PDF library, monitor ingestion progress, and show outcomes with deep hyperlinks again to the supply textual content.
On paper, that is all fairly simple. Python, Streamlit, SQLite+FTS5, FAISS, a sentence-transformer mannequin, every part wrapped in a Docker container. No unique cloud dependencies, only a personal NotebookLM‑ish software working on my machine.
The documentation-first method
I didn’t begin with code, however with the documentation. I already had my common undertaking skeleton from a cookiecutter template, so the construction was there: a spot for necessities, for design choices, for methods to deploy and check, all neatly sitting in a docs folder ready to be stuffed.
I wrote down the use case, sketched the structure, the algorithms to implement, the necessities. I described objectives, constraints, and main elements in a few bullet factors, then let genAI assist me increase the longer sections as soon as I had the tough thought in place. I subsequently moved steadily from a primary thought to filling out extra detailed paperwork describing the software. The end result wasn’t one of the best documentation ever, but it surely was clear sufficient that, in principle, I may have handed the entire bundle to a junior developer and they might have recognized what to construct.
Releasing my AI coworker into the codebase
As a substitute, I handed it to the machine.
I opened the doorways and let my GitHub Copilot colleague into the codebase. I requested it to create a undertaking construction as it might see match in addition to to fill within the required script information. As soon as a primary construction was set and the software appeared to work with one algorithm, I additionally requested it to generate the pytest suite, execute the check, and to iterate as soon as it bumped into any errors. As soon as this was accomplished, I continued asking it to implement additional algorithms and to cowl some edge instances.
In essence, I adopted my common method to software program growth: begin with a working core, then prolong with further options and make things better at any time when the rising assemble is working into main points. Is that this a globally optimum structure? In all probability not. However it’s very a lot within the spirit of the Pragmatic Programmer: preserve issues easy, iterate, and “ship” steadily — even when the cargo is simply inside and solely to myself.
And there’s something deeply satisfying about seeing your concepts materialize right into a working software in a day. Working with my AI coworker felt like being the undertaking lead I all the time wished to be: even my half‑baked needs had been anticipated and carried out inside seconds as largely working code.
When the code wasn’t working, I copy‑pasted the stack hint into the chat and let the agent debug itself. If it obtained caught in a self‑induced rabbit gap, I switched fashions from GPT5 to Grok or again once more they usually debugged one another like rival siblings.
Following their thought course of and seeing the codebase develop so rapidly was fascinating. I solely stored a really tough time estimate of this undertaking, as this was a aspect experiment, but it surely was actually no more than 25 hours to provide >5000 traces of code. Which is actually a terrific achievement for a comparatively advanced software that might have in any other case occupied me for a number of months. It’s nonetheless removed from excellent, but it surely does what I supposed: I can experiment with completely different fashions and summarization algorithms on high of a retrieval core that returns verbatim solutions from my very own library, together with the precise supply, so I can bounce straight into the underlying doc.
After which I left it alone for a month.
The technical debt hangover
Once I got here again, I didn’t need to add a significant characteristic. I simply wished to containerize the app in Docker so I may share it with a pal.
In my head, this was a neat Saturday morning activity. As a substitute, it became a weekend full‑time nightmare of Docker configuration points, paths not resolving appropriately contained in the container, embedding caches and FAISS indexes residing in locations I hadn’t clearly separated from the code, and exams passing on my native machine however failing (or by no means working correctly) inside CI/CD.
A few of these points are solely on me. I fortunately assumed that my CI/CD pipeline (additionally generated by AI) would “maintain it” by working exams on GitHub, in order that cross‑platform inconsistencies would floor early. Spoiler: they didn’t.
again when Copilot advised a seemingly easy repair: “Simply add a reference to the working listing right here.” As a substitute of letting it contact the code, I wished to remain in management and solely ask for instructions. I didn’t need it to wreak havoc in a codebase I hadn’t checked out for weeks.
That’s after I realized how a lot I had outsourced.
Not solely did I not notice why the error occurred within the first place, I may determine neither the file nor passage I used to be alleged to make the change in. I had no thought what was happening.
Evaluate that to a different undertaking I did with a colleague three years in the past. I can nonetheless recall how sure features had been intertwined and the silly bug we spent hours looking, solely to find that certainly one of us had misspelled an object identify.
The uncomfortable fact
I saved huge growth time by skipping the low-level implementation work. I stayed in command of the structure, the objectives, and the design choices.
However not the small print.
I successfully turned the tech lead on a undertaking whose solely developer was an AI. The end result appears like one thing a really quick, very opinionated contractor constructed for me. The code has unusually good documentation and respectable exams, however its psychological fashions by no means entered my head.
Would I be capable to repair something if I wanted to make a change and the web was down? Realistically: no. Or a minimum of not sooner than if I inherited this codebase from a colleague who left the corporate a yr in the past.
Regardless of the higher‑than‑common documentation, I nonetheless stumble over “WTF” code items. To be truthful, this occurs with human‑written code as nicely, together with my very own from a number of months again. So is GenAI making this worse? Or simply sooner?
So… is vibe coding good or unhealthy?
Truthfully: each.
The velocity is insane. The leverage is actual. The productiveness hole between individuals who use these instruments aggressively and people who don’t will solely widen. However you’re buying and selling implementation intimacy for architectural management.
You progress from craftsman to conductor. From builder to undertaking lead. From realizing each screw within the machine to trusting the robotic that assembled the automotive. And possibly that’s merely what software program engineering is quietly turning into.
Personally, I now really feel far more like a undertaking lead or lead architect: I’m in command of the large image, and I’m assured I may decide the undertaking up in a yr and prolong it. However on the similar time, it doesn’t really feel like “my” code. In the identical manner that, in a basic setup, the lead architect doesn’t “personal” each line written by their workforce.
It’s my system, my design, my accountability.
However the code? The code belongs to the machine.
