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 attempting to repair a bug in it — and realized I had no concept how my very own software program labored.
Let’s be trustworthy: 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, way more than I’m used to. Will I remorse it? Possibly. 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 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 assume is nearer to the corporate’s door when budgets tighten?
The productiveness good points are actual, even in case 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 very completely different realm of productiveness.
However right here comes my very private story, what I discovered, and the place I believe 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 non-public 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, it is a very scientific, barely paranoid method of utilizing your literature. However I’m most likely 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 sturdy 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 the very 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, the whole lot wrapped in a Docker container. No unique cloud dependencies, only a personal NotebookLM‑ish instrument operating on my machine.
The documentation-first method
I didn’t begin with code, however with the documentation. I already had my traditional venture skeleton from a cookiecutter template, so the construction was there: a spot for necessities, for design choices, for how you can 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 broaden the longer sections as soon as I had the tough concept in place. I subsequently moved step by step from a fundamental concept to filling out extra detailed paperwork describing the instrument. The outcome wasn’t the very best documentation ever, but it surely was clear sufficient that, in idea, I might have handed the entire bundle to a junior developer and they might have identified what to construct.
Releasing my AI coworker into the codebase
As an alternative, 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 could see match in addition to to fill within the required script recordsdata. As soon as a fundamental 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 traditional 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 operating into main points. Is that this a globally optimum structure? Most likely not. However it’s very a lot within the spirit of the Pragmatic Programmer: hold issues easy, iterate, and “ship” continuously — 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 all the time needed to be: even my half‑baked needs had been anticipated and carried out 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 acquired 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 venture, as this was a aspect experiment, but it surely was actually no more than 25 hours to supply >5000 strains of code. Which is actually an amazing achievement for a comparatively advanced instrument that might have in any other case occupied me for a number of months. It’s nonetheless removed from good, but it surely does what I supposed: I can experiment with completely different fashions and summarization algorithms on prime of a retrieval core that returns verbatim solutions from my very own library, together with the precise supply, so I can leap 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 serious function. I simply needed to containerize the app in Docker so I might share it with a good friend.
In my head, this was a neat Saturday morning activity. As an alternative, it become a weekend full‑time nightmare of Docker configuration points, paths not resolving accurately contained in the container, embedding caches and FAISS indexes dwelling in locations I hadn’t clearly separated from the code, and assessments passing on my native machine however failing (or by no means operating correctly) inside CI/CD.
A few of these points are completely on me. I fortunately assumed that my CI/CD pipeline (additionally generated by AI) would “handle it” by operating assessments on GitHub, in order that cross‑platform inconsistencies would floor early. Spoiler: they didn’t.
again when Copilot urged a seemingly easy repair: “Simply add a reference to the working listing right here.” As an alternative 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 after I realized how a lot I had outsourced.
Not solely did I not notice why the error occurred within the first place, I might establish neither the file nor passage I used to be alleged to make the change in. I had no concept 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 looking, solely to find that one in every 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 charge of the structure, the objectives, and the design choices.
However not the main points.
I successfully turned the tech lead on a venture whose solely developer was an AI. The outcome looks like one thing a really quick, very opinionated contractor constructed for me. The code has unusually good documentation and respectable assessments, however its psychological fashions by no means entered my head.
Would I have the ability 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 effectively, together with my very own from just a few months again. So is GenAI making this worse? Or simply sooner?
So… is vibe coding good or unhealthy?
Actually: 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 understanding each screw within the machine to trusting the robotic that assembled the automobile. And perhaps that’s merely what software program engineering is quietly turning into.
Personally, I now really feel way more like a venture lead or lead architect: I’m in charge of the massive image, and I’m assured I might decide the venture up in a yr and prolong it. However on the identical time, it doesn’t really feel like “my” code. In the identical method that, in a basic setup, the lead architect doesn’t “personal” each line written by their workforce.
It’s my system, my design, my duty.
However the code? The code belongs to the machine.
