The Vibe Police: My Sunday Dance with AI Development

Sing to the tune of Manic Monday by the Bangles:

“It’s just another coding Sunday I’m glad it’s not Monday Today’s my debug day My no-more-Teams-calls day It’s just another coding Sunday.”

It’s Sunday, and I’m knee-deep in code. Over the last several weeks, I’ve dedicated a big chunk of my Sundays to experimenting with an AI-assisted integrated development environment. I decided to use it in combination with chat sessions with a frontier model I have access to, for ideation, planning, and project management. I had an app idea in mind that I’d call a “mid-size” application – non-trivial functionality involving a mobile app, back-end services, relatively complex UI, data storage, file storage, and authentication. This is a REAL app, not a toy.

I have to admit, the first couple of sessions were rough. After the first night, when I got up from my desk at 1 AM, I was discombobulated, and the coding vibes were “mixed.” On the one hand, I could see the massive capability shift; on the other, did I want to strangle the “agents” I’d been working with? Well, definitely, yes!

Now, this Sunday, I feel I’ve settled into a rhythm, and I thought I’d share my notes to help you get there faster.

Architectural Decisions

You’ll want to debate key decisions upfront and, if needed, investigate framework suitability in a separate context. The AI sometimes gets oddly defensive about its initial choices, as if it were a consultant protecting its methodology. This was quite painful to realize: we need to detail requirements as if we’re back in the pre-agile waterfall days! The try-quick-and-iterate approach can send you down spectacularly wrong paths. I think it’s because in standard people-based agile settings, we have more shared assumptions and context about what comes next. With AI-assisted development, it’s better to give the full scope and double-check whether proposed frameworks actually scale to the problem and the end goal, not just to the next step.

Case in point: I had a particularly challenging drag-and-drop feature in a mobile UI. Users needed to lock components together, drag them as groups, and visually establish sequences. The AI’s brilliant first solution? FlatList React Native components with various animation frameworks. We spent hours going in the wrong direction, like trying to build a Formula 1 car with bicycle parts. After calling “timeout” and resetting the context, the agent recognized the problem but still suggested solutions that addressed just the next couple of steps rather than scaling for the full feature described in the spec. Only after a very detailed requirements chat – think old-school systems analyst thoroughness – did we land on a clean, working solution.

Infrastructure Setup

Local setup remains a problem I had to solve manually. Homebrew installs, environment variables, conflicts, package manager disputes, system-level configurations – better to handle these in the terminal rather than letting the AI attempt to manage local environment setup. The IDE tries to handle all the setup in its own sandbox, but that won’t work with everything.

SaaS and PaaS setup reveals the AI’s tendency toward optimistic incompleteness. Instructions are generally solid until they’re not, particularly around key management. I started maintaining a local note file, like a medieval scribe, after the development environment repeatedly lost track of downloaded config files. Managing Google Cloud and Firebase consoles while the AI cheerfully forgets critical details? That’s a special Sunday afternoon activity. I suggested (and we implemented) the proper approach for loading local configuration files, ensuring we don’t commit secrets to the repository.

Down the Rabbit Hole (Or: When Digital Relationships Turn Toxic)

Here’s my hard-earned rule: if a specific problem takes longer than an hour, regenerate your specs and restart with fresh context. Continuing to iterate with a degrading AI context is like trying to have a productive argument with someone having a breakdown – it only gets worse.

The truly bizarre part? Heavy self-flagellation starts when failures pile up, and I find myself developing a genuine dislike toward this instance of the agent. What’s particularly maddening is knowing it’s just sophisticated word soup – there’s no actual developer to forgive or throttle, just statistical patterns pretending to have feelings. After the twentieth failure, the AI starts making increasingly desperate promises: “This next solution will definitely work!” and “I’m confident this approach will solve everything!” Nobody believes this after the first few disappointments, creating a downward spiral of digital dysfunction. I’ve tried instructing agents upfront to stick to facts and skip the emotional theatrics, but even that only lasts for a while. Eventually, it regresses toward the same empty promises and begging for forgiveness.

Destructive Development

Git checkpoints become absolutely critical when your AI partner develops a talent for spectacular failures. But here’s the catch: rolling back code means the AI loses context and starts asking for fresh copies of files it can no longer locate in its digital memory. I’ve experienced multiple regressions where the AI would correctly fix deprecated functionality, then cheerfully revert to the broken solution a few iterations later, like a goldfish with commitment issues. Maybe I need permanent context rules: “Approach X is forbidden forever and ever, amen.” Starting fresh context after rollbacks might be more efficient than trying to realign a confused AI with restored code. It feels wasteful, but sanity preservation is worth the overhead.

Role Playing (Or: Managing Your Digital Team)

Multi-agent workflows show real promise. Having one agent play product manager while others handle development creates interesting dynamics, though the “master” agent tends to be incredibly opinionated about delivering complete solutions and always resorts to giving code, rather than collaborative problem-solving.

Given that context degrades faster than my patience, maintaining transferable documentation becomes a survival skill. When conversations start circling the drain, I prompt for updated PRDs and architectural decisions that can survive the transition to fresh contexts. I started having the agent capture key learnings from debug sessions into a separate Architectural Findings document, which I can load into the next context alongside the main PRD and plan files, so that hopefully the next agent instance can learn from previous mistakes. We’re throwing away shared learnings and nuances, but it beats digital madness. Ideally, we’d have an additional agent – maybe a business analyst role – with no opinions beyond carrying maximum context between sessions. A digital memory keeper without the emotional baggage.

The Sunday Verdict

Despite all the digital drama, I keep coming back every Sunday. Why? Because when it works, it’s genuinely transformative. The speed of iteration for certain problems is remarkable, and the ability to explore ideas quickly opens up possibilities I wouldn’t have attempted manually.

We’re developing new workplace psychology around AI collaboration – managing brilliant but unstable digital colleagues who forget everything, make wild promises, and occasionally deliver genuine breakthroughs. It’s like managing the world’s most talented intern who’s also having a nervous breakdown.

The technology is advancing faster than our ability to work with it effectively. These Sunday experiments help me understand how to leverage these capabilities while managing the peculiarities that come with the territory. And I can, with confidence, help our clients deploy the tools and processes to deliver value.

I’m done for the day. I think one complex area is sorted. I made sure to stop right after something works, so I don’t dread coming back to a mess. Looking forward to next Sunday: I’ll get started with the next feature! Or maybe just endlessly debug whatever spectacular mess the agent and I create next.