Vibe Coding Forem: David Gallivan

The Case of the Wandering Columns

David Gallivan — Wed, 26 Nov 2025 23:46:37 +0000

A Cautionary Tale for Developers Who Depend on AI a Little Too Much

Let me tell you a story---a tale of mystery, betrayal, and one very
uncooperative Excel spreadsheet.

It all started on a perfectly normal afternoon. Birds were chirping,
coffee was warm, and my application---poor, innocent thing---was trying
to read data from Excel files. Yes, I know, using Excel as a data source
is like using a cheese grater as a pillow... but that wasn't the main
problem.

The Real Problem

The columns in the spreadsheet kept moving.

Not shifting, not rearranging politely---no, these things were doing the
Electric Slide every time someone exported the file. My parser would
line up the data like, "Okay, column 3 is EmployeeName---got it."\
Then the next day:\
Column 3 is suddenly BudgetVariance, column 10 is now
EmployeeName, and column 5... well, column 5 has gone missing
entirely.

My parser basically had the same expression you get when your GPS yells,
"Make a U-turn! MAKE A U-TURN!"

What We Tried (AKA: The AI Phase)

Naturally, I called in backup: AI.

Together, we built:

A fancy Excel parser using NuGet packages\
A CSV parser\
A backup parser for when the first two parsers got tired\
Several emotional support console logs

And it worked!\
Until the next spreadsheet arrived and the columns once again decided to
practice interpretive dance.

We considered switching to an API or getting a stable export format...\
But the vendor said:

"No."

And by "no," I mean:

"Sure, we can help---but only if you pay us enough to buy a small
island."

So AI and I kept throwing solutions at the problem like two raccoons
frantically trying to open a locked trash can.

The Breakthrough (AKA: The Part Where Human Brains Still Matter)

After hours of trying every AI suggestion---including a few that made my
computer visibly shake its head---I stepped back and looked at the
problem like an engineer instead of a prompt typist.

Then it hit me:

Dynamic types.

The forgotten, dusty corner of C# where magical things can happen.

If the columns wanted to move around like caffeinated toddlers?\
Fine.\
I'd fetch values dynamically and then map those values to the model I
already had.

Let the spreadsheet do its dance---I'd catch the values mid-air.

And guess what?

It worked.\
It worked beautifully.\
It was even faster than the original parser.

AI: "Wow, that was clever."\
Me: "I know."\
Excel: "Fine, I'll stop moving columns now."\
(Excel was lying.)

What I Learned (AKA: The Moral of the Story)

AI is an incredible partner.\
It can generate code, suggest libraries, scaffold ideas, and even talk
you through debugging your existential crisis.

But here's the part everyone needs to tattoo on their brain:

You still have to know how to code.

You still have to understand the language you're using.\
You still need real engineering instincts.

AI is trained on public code---written by millions of people who never
encountered your specific spreadsheet horror movie. It can get you
close, but sometimes it doesn't know the trick you know because you
actually understand C#.

The only reason I found the solution?

"Hey... C# has dynamics. Those could solve this."

AI didn't think of it.\
But I did.\
And when we combined forces---my experience + its suggestions---we
solved the problem.

Final Moral

AI is your co-pilot, not your parachute.\
You can't outsource understanding.\
If you want to solve real problems, you and AI need to pair
program---and you need to know the language well enough to steer it in
the right direction.

The Invisible Path of Vibe Coding: Why Infrastructure Must Come Before the Fun Stuff

David Gallivan — Sun, 19 Oct 2025 17:32:37 +0000

If you've ever vibe-coded your way through an app - riding that creative high as AI generates your UI in real time - you know the rush. Buttons appear, data binds instantly, the app feels alive. It's addictive.

But here's the uncomfortable truth: most developers who embrace vibe coding (AI-assisted, flow-state, rapid-prototype development) fall into the same trap. They build what looks like a complete application - beautiful, interactive, even feature-rich - only to discover when it's time to deploy that the invisible path has been completely neglected.

And that's when reality hits.

The Illusion of Progress

Vibe coding thrives on visible feedback. You type a prompt or tweak a line, and the screen responds instantly. You see results, get dopamine, and keep going.

The problem?
What you see is not what you'll deploy.

Under the hood, your app might be missing:

Logging
Monitoring
Error handling
Configuration management
Authentication and authorization
Environment separation
Observability hooks
Deployment pipelines
Alerting and notifications

These invisible systems aren't glamorous. They don't animate or sparkle. But they're what separate a demo from a dependable application.

The Real Foundation: Infrastructure First

Before you build a single page or prompt an AI to generate your UI components, establish the **foundation **that every production-ready app depends on.
Here's a non-negotiable checklist:

1. Configuration & Environments

Create environment-specific settings early:

appsettings.Development.json, 
appsettings.Staging.json, 
appsettings.Production.json

Use feature flags for experimental features
Keep secrets out of code (Key Vault, Secret Manager, etc.)

The goal: make your app deployable to any environment without editing code.

2. Logging

Add structured logging from day one:

Use Serilog, Application Insights, or OpenTelemetry
Capture context (user, request ID, operation)
Store logs centrally for correlation

Logging is how you talk to your production environment.

3. Monitoring

Set up health checks and metrics before you have users:

Application Insights, Prometheus, or New Relic
Custom telemetry for performance and usage
Dashboards that visualize system behavior

Without monitoring, you're driving blindfolded.

4. Error Handling & Alerts

Don't just catch exceptions - report them:

Centralized exception handling middleware
Automatic alerts (email, Slack, Teams, PagerDuty)
Graceful user-facing messages

Errors should wake you up before they wake your users.

5. Notifications & Auditing

Include notifications early - not as an afterthought:

System notifications for job failures, thresholds, or workflow events
Audit logs for every significant user or system action

Every production system should be able to answer: "What happened, and who did it?"

6. Security & Access

Even prototype users deserve protection:

Secure endpoints, API keys, and credentials
Role-based access control (RBAC)
Token validation and HTTPS enforcement

It's always cheaper to build security in than bolt it on later.

The Invisible Path: Why It's Hard to See

**
Most developers don't skip infrastructure out of ignorance - they skip it because there's no visual feedback.

A logging system doesn't "look" like anything.
Monitoring doesn't sparkle.
Alerts don't animate.
And dashboards are usually blank until something goes wrong.

But these invisible systems are the backbone of trust, reliability, and scale. They're what allow your app to evolve beyond the demo phase - to survive real users, real load, and real expectations.

Turning Vibe into Vision

**
Vibe coding isn't the enemy. In fact, it's one of the most exciting developments in modern software. The key is to direct that vibe into the right order.

Here's the formula:

Start with the Infrastructure

Logging
Monitoring
Configurations
Secrets
Pipelines

Then Add the UI

Let AI build the components, styles, and interactions.
But make sure they sit on top of a solid foundation.

Finally, Connect the Two

Hook your vibe-coded components into telemetry, authentication, and notifications.

That's how you vibe code responsibly - with intent and architecture.

Example: From Demo to Deployment

Imagine building a small task tracker.

You prompt your AI: "Create a Blazor page with a task list, add/edit/delete buttons, and save tasks locally."

Looks great. It runs. You feel done.

Now try to deploy it for real:

Where will the logs go?
What if the API fails?
How will you know if it's down?
How do you separate dev from prod data?
What happens when you have 100 users instead of one?

That's when the invisible path reveals itself.
Every shortcut you took in the name of speed becomes a rework item.

The Vibe-First, Infra-Later Paradox

Vibe coding teaches speed.
Production requires discipline.
The trick is to combine them:

Use vibe coding for rapid prototyping inside a predefined infrastructure template.
Treat your infrastructure setup as part of your vibe toolkit — not an afterthought.

When infrastructure is invisible, failure becomes visible.

Final Thought

The next generation of developers will code side by side with AI. But if we don't teach them to see the invisible path - to value logging, monitoring, security, and observability as much as aesthetics - we'll keep producing beautiful apps that can't survive the real world.

Build your foundation first.
Then let the vibe flow.