2025¶

Document or Die: Why Your Code's DNA Determines Its Survival in the AI Era

The biggest nightmare in software development just became irrelevant.

For decades, code duplication was the cardinal sin that haunted every large codebase.

Change one authentication flow, and you'd spend days hunting down every copy scattered across your system.

Miss one, and you'd have inconsistent behavior lurking like a time bomb.

We built entire philosophies around avoiding this pain – DRY (Don't Repeat Yourself), principles, complex inheritance hierarchies, elaborate abstraction layers.

With modern AI, code duplication doesn't matter anymore.

When AI can rewrite 1,000s of instances of duplicated code in minutes based on a single instruction, the entire foundation of how we think about software architecture crumbles.

Suddenly, having multiple copies isn't a liability – it's just another pattern that AI can transform instantly.

The real game-changer isn't that AI can write code. It's that AI can rewrite entire codebases based on the rules you give it.

Need to update authentication logic across 50 microservices? Tell the AI your new rules, and watch it propagate the changes perfectly in minutes, not months.

This shifts everything.

The quality of your code no longer depends on avoiding duplication – it depends entirely on the quality of the DNA you use to generate it.

• Your documentation.
• Your rules.
• Your architectural patterns.

They're not just descriptions anymore.

They're the genetic instructions that determine whether your software thrives or dies in this new ecosystem.

Let me show you why mastering this evolutionary approach isn't optional – it's survival.

AI Darwinism: Why RAG Will Never Die

The Predictable Death of RAG (According to Twitter)

Like clockwork, every time a new large language model (LLM) announces a bigger context window, the hot takes flood social media:

"RAG is dead! Just stuff everything into the 10 million token context!"

This take is not just wrong, it's idiotic.

While massive context windows are impressive, simply dumping data into them is like trying to find a specific sentence by reading an entire library.

It's inefficient and ignores the real challenge: feeding the LLM the right information at the right time.

Anyone building real-world LLM applications knows this.

The secret isn't just more context; it's smarter context.

This post introduces the concept of Context Optimization—the evolution of RAG in the era of large context windows.

You'll learn why strategically selecting and presenting relevant information is crucial for maximizing performance, minimizing costs, and building AI systems that actually work in production.

Internalize this Context Optimization mindset, and you'll understand why RAG, far from being dead, is more vital than ever.

Let's dive in.

Transactions, Commits, and Rollbacks in SQLModel: A Mental Model That Actually Makes Sense

Every developer working with databases has experienced that frustrating moment when their application grinds to a halt because of connection issues or unexplained slowdowns.

If you've ever wondered why your SQLModel operations are crawling along or connections are being dropped, you're not alone.

The problem isn't your code's logic - it's how you're managing database sessions.

I learned this the hard way after creating bottlenecks by constantly opening new connections instead of properly managing and reusing sessions.

By the end of this post, you'll understand:

• Why creating a new session for every operation kills performance
• When exactly you should commit() or rollback()
• A simple mental model that makes SQLModel transactions intuitive
• Bulletproof patterns for managing database connections efficiently

The best part? You'll never again wonder why your application is suddenly crawling along due to connection pool exhaustion.

Inside the Eye of AI's Storm: The Ghiblication Moment

Every technological revolution has its moments of collective exhale—brief pauses where wonder overtakes worry and creativity eclipses concern.

For AI in 2025, that moment came wrapped in the nostalgic, hand-painted aesthetic of Studio Ghibli.

In the relentless acceleration of AI advancement, "Ghiblification" emerged as a rare moment of calm in the center of the storm—where instead of fretting about jobs or fixating on business cases, people simply played, created, and shared joy.

But this calm center tells us something profound about both where we've been and where we're heading.

As someone who's navigated these waters professionally since before ChatGPT altered our landscape, I see something important in this brief respite that might help you prepare for what comes next.

Vibes Fade, Knowledge Lasts: The Case Against Lazy Coding Culture

Every time I scroll through my Twitter feed lately, I'm bombarded with content celebrating "vibe coding" – the idea that you don't need deep technical knowledge anymore, just the right "vibes" and an LLM to generate your code.

Something about this trend doesn't sit right with me.

It's not professional jealousy. As someone who uses AI coding tools daily, I recognize their transformative potential. Rather, it's the underlying philosophy that troubles me – the casual dismissal of accumulated knowledge and the experts who built it.

While watching the anime Orb: On the Movements of the Earth recently, I had an epiphany about what specifically bothers me about vibe coding culture.

Skip Manual Labeling: How You Can Automatically Caption Images with Spacial Awareness for Any Product

Have you ever stared at thousands of product images, dreading the manual labor of tagging each one for AI training?

Capturing every nuance by hand is a daunting (and expensive) task.

Yet structured annotations are the lifeblood of machine learning.

The rule is simple: garbage in, garbage out.

A high quality image caption needs to capture:

• Exact object locations in complex scenes
• Relationships with surrounding elements
• Environmental context and lighting conditions
• Consistent descriptions at scale

That's exactly where our client found themselves - facing 10,000+ images of custom textured walls that needed precise labeling for fine-tuning a diffusion model.

Using a combination of Florence 2, GPT-4o Vision, and the Instructor library, you'll see how to build a reliable system that:

• Automatically detects and localizes objects
• Generates structured, validated descriptions
• Handles spatial relationships systematically
• Scales from 50 to 50,000+ images without compromising quality

Best of all? We did it without any custom models or infrastructure.

Here's the complete technical breakdown of how we turned a month-long manual process into an automated pipeline that runs in hours.

How You Can Save 20,000+ Hours a Year with a Secure, GPT-Driven Meeting to Email Workflow

Your team is wasting thousands of hours manually writing follow-up emails after Zoom meetings.

Every day, they:

• Battle with meeting recordings
• Miss capturing action items
• Triple-check that sensitive data hasn't been exposed

For a mid-sized organization, this adds up to tens of thousands of wasted hours annually.

What if you could transform every Zoom transcript into a perfectly structured follow-up email in under 60 seconds, while keeping your sensitive data completely secure?

This post will show you how to:

• Build a GPT-powered system that automatically converts meetings into action-ready emails
• Protect sensitive data by keeping everything in your control
• Save your organization 20,000+ hours annually on email drafting
• Ensure 100% accuracy with domain-specific terminology correction
• Create traceable links between action items and meeting timestamps

See It In Action

In this demo, you'll see:

• A real meeting transcript being processed in under 60 seconds
• The automated extraction of key points and action items
• How sensitive data is handled securely
• The final formatted email output ready to send

This automated workflow reduces a 30-minute manual process to just a few clicks while maintaining complete data security and accuracy.

---

The Real Cost of Manual Meeting Follow-ups

For a team of 50 people averaging just two client calls per week, manual follow-up emails waste 12,500 hours annually.

Here's what your team currently spends 30 minutes doing after every call:

The Honest Path to Leveling Up Your AI Consulting Career

Last month, I did something that would make most consultants cringe:

I offered to work for free on a $20-30 million company's AI strategy.

When Alex Hormozi said, "You're not good enough yet... and that's okay," it resonated deeply as I stared at a potential six-figure contract, knowing I wasn't quite ready for it.

We're constantly told to "charge what we're worth" and "never work for free."

But here's the uncomfortable truth about scaling an AI consulting practice.

Sometimes, the fastest way up is to admit you're not at the top yet.

The real challenge of enterprise AI consulting isn't just technical expertise – it's the catch-22 of needing enterprise experience to land enterprise clients.

You can't access the rooms where high-level decisions happen until you've already been in those rooms.

Here's what nobody tells you:

The path to doubling or tripling your consulting income isn't always about charging more – sometimes it's about making strategic "losses" that compound into massive gains.

In this post, I'll show you exactly how I'm using what I call the Strategic Loss Leader approach to:

• Land clients 10x larger than my usual target market
• Transform "free" work into six-figure opportunities
• Position myself for deals I currently have no right to win

It's not about underselling yourself.

It's about being strategic and honest about where you are in your journey – and then doing something about it.