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? Perhaps. Will you?
I needed to share my story right here as a result of I imagine that is one thing many builders are going by means of proper now, and much more will expertise it within the coming years.
As a result of let’s face it: you may have a code of honor and be happy 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 good points are actual, even for those who solely use these instruments for documentation. And there’s a tiny step from:
“Write docstrings for this operate.“
to
“Write the operate.“
That tiny immediate step skyrockets you into a totally totally 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 venture: 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 authentic 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 uninterested in fact-checking each LLM response towards the supply.
The structure of the software program was pretty easy:
- A strong ingestion pipeline: strolling listing bushes, extracting textual content from PDFs, and normalizing it into paragraphs and overlapping chunks.
- Hybrid Storage & Retrieval: a storage layer combining normal 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 drag 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 easy. Python, Streamlit, SQLite+FTS5, FAISS, a sentence-transformer mannequin, every thing wrapped in a Docker container. No unique cloud dependencies, only a personal NotebookLM‑ish instrument operating on my machine.
The documentation-first strategy
I didn’t begin with code, however with the documentation. I already had my regular venture skeleton from a cookiecutter template, so the construction was there: a spot for necessities, for design selections, for methods to deploy and check, all neatly sitting in a docs folder ready to be crammed.
I wrote down the use case, sketched the structure, the algorithms to implement, the necessities. I described targets, constraints, and main elements in a few bullet factors, then let genAI assist me develop the longer sections as soon as I had the tough thought in place. I subsequently moved step by step from a primary thought to filling out extra detailed paperwork describing the instrument. The outcome wasn’t one of the best documentation ever, however it was clear sufficient that, in concept, I may have handed the entire bundle to a junior developer and they’d 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 venture construction as it will see match in addition to to fill within the required script recordsdata. As soon as a primary construction was set and the instrument 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 achieved, I continued asking it to implement additional algorithms and to cowl some edge circumstances.
In essence, I adopted my regular strategy to software program growth: begin with a working core, then prolong with extra options and sort things each time the rising assemble is operating into main points. Is that this a globally optimum structure? Most likely not. Nevertheless it’s very a lot within the spirit of the Pragmatic Programmer: hold issues easy, iterate, and “ship” steadily — even when the cargo is just inside and solely to myself.
And there’s something deeply satisfying about seeing your concepts materialize right into a working instrument in a day. Working with my AI coworker felt like being the venture lead I at all times needed to be: even my half‑baked needs had been anticipated and applied inside seconds as principally 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 bought 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 saved a really tough time estimate of this venture, as this was a aspect experiment, however it was actually no more than 25 hours to supply >5000 strains of code. Which is actually an amazing achievement for a comparatively complicated instrument that might have in any other case occupied me for a number of months. It’s nonetheless removed from excellent, however it does what I supposed: I can experiment with totally 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 wish to add a significant function. I simply needed to containerize the app in Docker so I may share it with a good friend.
In my head, this was a neat Saturday morning process. 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 dwelling in locations I hadn’t clearly separated from the code, and checks passing on my native machine however failing (or by no means operating 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 “care for it” by operating checks on GitHub, in order that cross‑platform inconsistencies would floor early. Spoiler: they didn’t.
again when Copilot steered a seemingly easy repair: “Simply add a reference to the working listing right here.” As a substitute of letting it contact the code, I needed 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 once 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 speculated to make the change in. I had no thought what was occurring.
Evaluate that to a different venture I did with a colleague three years in the past. I can nonetheless recall how sure capabilities had been intertwined and the silly bug we spent hours searching, solely to find that one among us had misspelled an object identify.
The uncomfortable reality
I saved huge growth time by skipping the low-level implementation work. I stayed accountable for the structure, the targets, and the design selections.
However not the small print.
I successfully grew to become the tech lead on a venture whose solely developer was an AI. The outcome seems like one thing a really quick, very opinionated contractor constructed for me. The code has unusually good documentation and first rate checks, however its psychological fashions by no means entered my head.
Would I be capable of repair something if I wanted to make a change and the web was down? Realistically: no. Or at the least not quicker than if I inherited this codebase from a colleague who left the corporate a 12 months in the past.
Regardless of the higher‑than‑common documentation, I nonetheless stumble over “WTF” code items. To be honest, this occurs with human‑written code as properly, together with my very own from a number of months again. So is GenAI making this worse? Or simply quicker?
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 venture lead. From figuring out each screw within the machine to trusting the robotic that assembled the automotive. And perhaps that’s merely what software program engineering is quietly turning into.
Personally, I now really feel far more like a venture lead or lead architect: I’m accountable for the massive image, and I’m assured I may choose the venture up in a 12 months and prolong it. However on the identical time, it doesn’t really feel like “my” code. In the identical manner that, in a traditional setup, the lead architect doesn’t “personal” each line written by their staff.
It’s my system, my design, my accountability.
However the code? The code belongs to the machine.
