How I Turned a Weekend Project into an Existential Crisis

How a two‑week plugin turned into a 46,081‑line chaos spiral—and what I learned.

So here's the thing about scope creep: it's like agreeing to help your friend move “just a few boxes” and somehow ending up disassembling their entire kitchen while they’re at work. Except in this case, I’m both the friend asking for help and the idiot with the screwdriver, and the kitchen is a fucking Obsidian plugin that was supposed to take two weeks.

Two weeks, I told myself! Build a simple tool that scans my notes and spits out some AI-generated insights. Easy. Done. Ship it.

That was four months ago.

What I Said I Was Building

“RetrospectAI: A simple Obsidian plugin that helps users reflect on their notes.”

You know what that means in normal-person speak? Scan some markdown files, ask ChatGPT what it thinks, and make a summary note. Boom. Done. The kind of thing you build on a weekend when you're procrastinating on literally anything else more important. Additionally, I would be “vibe coding,” meaning the AI would handle the bulk of the actual programming.

The user story was embarrassingly straightforward: “As an Obsidian user, I want to automatically discover patterns in my daily notes and get AI-generated insights to help me reflect on my thoughts and progress.”

Simple, right? Like asking for a grilled cheese sandwich!

What I Actually Built

A sophisticated, enterprise-grade AI orchestration platform.

Let me write that out again: Without really realizing it, I accidentally built a sophisticated, enterprise-grade AI orchestration platform.

I wish I were joking.

Somewhere between “scan some files” and “ship it,” I apparently decided that what the world really needed was a multi-provider AI abstraction layer with a four-tier caching system and comprehensive audit logging. Because when someone asks for a grilled cheese, obviously they want you first to build them a commercial kitchen, complete with industrial refrigeration and a FUCKING FIRE SUPRESSION SYSTEM.

Let me just... let me walk you through this disaster:

• The AI Model Abstraction Layer: Instead of just calling the OpenAI API like a normal person, I built a unified interface that supports OpenAI, Ollama, local models, and probably carrier pigeons if you configure it right. Because what if someone wants to use a different AI provider? What if they're going to run everything locally for privacy reasons? What if they want to train their model on their grocery lists? I HAD TO BE READY FOR EVERYTHING.
  

• The Privacy System: Oh, this is good. This is where I really went off the rails. Instead of just letting people exclude files with a toggle, I built an enterprise-grade privacy compliance system that provides file-level exclusion, tag-based filtering, section-level redaction, and comprehensive audit logging. I have audit logs for a personal reflection tool. It's like installing a bank vault door on your diary.
  

• The Pattern Detection Engine: This is the crown jewel of my overthinking:

  • 2,000+ lines of code.

  • 13 different pattern types.

  • 876 lines of unit tests

  • A four-tier caching system (An AI told me it was good, so I said, “Add it, hey, why not?”)

All of that code… to build a miniature version of the analytics engine LinkedIn uses to determine which former colleagues to suggest you connect with.

The scope multiplier? About 6x the original vision. I took a weekend project and turned it into something that would require a sprint planning meeting and a product manager.

The MVP Already Works (But I’m Still Holding It Hostage)

At first, I thought that all the generated enterprise-level code was a good thing. “Oh, okay. Ernie took a godly amount of time off because he was building an enterprise-grade AI platform!”

I mean, sure—I learned something from building this full-scale enterprise solution. But not nearly as much as you’d think. Or as much as I should have, given how much time I spent pretending I understood what I was building. And honestly, that’s sad.

An hour ago, I finally sat down and wrote this project overview—you know, the thing you're supposed to do before you start building, not after you've already constructed a monument to your inability to focus, because this has been a project I have thought about for months and it was still not even close to being in a state I was happy with.

Current state: 85% ready for publication.

What's blocking publication? The fact that I'm treating this like it needs to pass some enterprise software audit. I've got comprehensive testing suites. Performance monitoring. An extensible plugin architecture for future developers who will probably never exist.

You know what users actually need?

• Scan their notes ✅ (This already works)

• Get some AI insights ✅ (This already works)

• Create a summary ✅ (This already works)

• Keep their private stuff private ✅ (This already works)

• Configure it without a computer science degree ✅ (This already works)

The MVP has been sitting there, fully functional, buried under four months of “but what if someone wants to...” engineering.

The Moment of Clarity

Whether this is a textbook engineer's brain, an ADHD brain, or a combination of both, I should know better by now. I’ve done this before—not the building-too-much part, but the part where I get so excited about what’s possible that I lose track of what’s necessary.

It’s like when you’re trying to write a simple blog post about your day and somehow end up crafting a 3,000-word philosophical treatise on the nature of time. (Which is basically what this newsletter has become most weeks.)

But here’s the really embarrassing part: I didn't even build most of this shit myself. I was what you might generously call “vibe coding” —basically me sitting there typing “looks good” and “okay” and “yeah add it” and “sure i guess” and eventually just “fuck it” while Claude AI happily constructed my enterprise-grade monument to feature creep.

At one point, Claude had a couple of major hallucinations building some of those enterprise features, but those enterprise features were so abstract that it took weeks to realize that, you know what? Maybe I don’t need insight-prioritization-engine.ts or markdown-formatter-factory.ts, especially since they had methods that weren’t used anywhere in the application.

It’s like I accidentally became the world's most enthusiastic product manager for an AI that was perfectly willing to build me whatever ridiculous thing I half-heartedly approved in the moment.

“Four-tier caching system? Sure!”

“Comprehensive audit logging? Why not?”

“Plugin architecture for hypothetical future developers? Obviously!"

The real kicker? Everything users actually want is already working. Right now. Today. I could package this thing up, submit it to the Obsidian community plugins, and people could be using it by next week.

But instead, I’ve been sitting here for months saying “yes” to increasingly complex solutions to problems that don’t exist. Because clearly what Obsidian users really want is enterprise-grade cache invalidation strategies that I didn’t even write myself.

The Recovery Plan

So here’s what I’m doing, because apparently I need to stage an intervention on my own project:

Step 1: Realize I was the problem. Yesterday, I wrote a new prompt into Cursor, my vibe IDE of choice:

After a lot of trial and error, I realized that my enterprise solution's Obsidian plugin was too complex, and I would like to ship a much simpler version within 24 hours. What do I need to do? Ask questions where necessary.

I put this prompt in both Cursor and Aider (the command line version of Cursor). Both versions recommended that I toss the code and start from scratch, this time with the most basic functionality to address what I wanted it to do at the end of the day: give clarity on my daily and weekly notes.

And there it was—my final version… 46,081 lines of code less than the previous version, a 99.5% reduction.

Forty six thousand eighty fucking one lines of fucking code.
Ninety-nine point fucking five.
Can I throw in a couple more F bombs?
Because this one was a doozy.

Step 2: Create an MVP branch. Strip out all the enterprise bullshit. Take the working parts—the ones that actually solve the original problem—and package them up like the simple tool they were supposed to be.

Step 3: Test it with actual humans. (Hey, you, reading this: you’re human! Do you use Obsidian and find yourself needing AI insights for your stuff? Email me.) Write documentation that doesn't require a computer science degree.

Step 4: Ship the fucking thing by submitting it to the Obsidian Plugin Directory.

Step 5: If people actually use it and request the advanced enterprise features, then I can gradually add them back. If not, I'll have saved myself from building a Formula 1 car for someone who just wanted to bike to the corner store.

The Bigger Picture

This isn’t the first time I’ve done this, and it probably won’t be the last. There’s something deeply satisfying about building elegant systems, about anticipating every possible edge case, about creating something that could theoretically scale to handle millions of users even though you know damn well it’ll have maybe fifty.

It’s the same impulse that makes me reorganize my entire note-taking system instead of just writing the actual notes. The same impulse that makes me spend three hours researching the perfect productivity app instead of just doing the work.

Building complex systems feels like progress. It feels like you’re really engineering something. Simple solutions feel... too simple.

Like you’re not trying hard enough. Like you’re cutting corners.

There’s a part of me that hasn’t faced the truth that where a lot of engineers zigged and levelled up their IC skills, I zagged and very much took a lateral approach, going so far as to go into instructional design the past couple of years.

And here I am, waltzing back into the Bay Area, thinking I could have an engineering job as if I hadn’t made lateral jumps. Maybe this is why I’m having such a hard time finding a job.

But you know what actually matters? Whether the thing works for the people who need it.

RetrospectAI—even in its current, over-engineered glory—does work. It scans your notes, generates insights, respects your privacy, and creates useful summaries. It does exactly what I said it would do in that original two-week scope.

The fact that it also happened to once include an enterprise-grade AI orchestration platform is... well, it's a learning moment.

The Real Lesson

Scope creep isn’t always about outside pressure. Sometimes it’s just your brain chasing problems that don’t exist yet.

The best thing you can build is often what you first imagined.

Good enough really can be good enough.

Publishing means exposing parts of yourself you weren’t ready to share—but you do it anyway, because there’s nothing left to lose.

(Seriously, someone needs to ask me, “Bicycle or space shuttle?” before I start building.)