How AI Agentic Coding Changed Everything

There's a moment every developer knows: You want to try something. You have an idea. But you look at your codebase and think, "This would take all day. And I might break everything. And I'd have to update all the tests. And..."

So you don't try it.

AI agentic coding killed that hesitation.

And in killing it, it fundamentally changed how we built Bonjour.

What Changed

Let me be specific about what "AI agentic coding" means for us.

Not autocomplete. Not "GitHub Copilot suggests the next line." Those are helpful, but they're incremental.

I'm talking about tools like Claude Code and Cursor in Agent mode. Tools that can:

Understand a feature request
Read through your entire codebase
Make changes across multiple files
Run tests and fix failures
Iterate until it works

It's the difference between "help me write this function" and "build this feature."

The Old Way

Here's how we used to work, even at iteration 5 when we were "fast":

Me: I want to add a feature where you can @mention teammates in notes.

Then:

Research how @mentions work (30 min)
Design the data model (20 min)
Update the database schema (10 min)
Write the backend logic (2 hours)
Update the frontend (2 hours)
Add tests (1 hour)
Debug edge cases (1 hour)
Update documentation (30 min)

Total time: 7-8 hours for one feature.

The New Way

Me: I want to add a feature where you can @mention teammates in notes.

Claude Code:

Reads the codebase
Identifies the relevant models and controllers
Updates the schema
Implements the mention parser
Updates the views
Adds tests
Asks clarifying questions when something is ambiguous

Total time: 45 minutes. And I barely wrote any code.

This Sounds Like Hype

I know. This sounds like a VC pitch. "AI will 10x your productivity!"

I was skeptical too.

But here's the thing: It's not about writing code faster. It's about experimenting without fear.

Experimentation Became Free

Before AI coding, every experiment had a cost.

"Should we try a different layout for the feed?" → 3 hours of work. Better be sure it's worth it.

"What if we reorganized the bucket system?" → 5 hours of refactoring. Only try if you're confident.

"Could we add real-time collaboration?" → 2 days of WebSocket implementation. Don't even think about it.

With AI coding, those experiments became:

"Let's try this" → 20 minutes
"Hmm, not quite right" → 15 minutes to adjust
"Actually, let's try a completely different approach" → 30 minutes
"Perfect!" → Ship it

The cost of being wrong dropped to almost zero.

How It Changed Bonjour

This isn't theoretical. Here are real examples of features we only built because AI made experimentation cheap:

1. The History View

We always wanted a history view—a timeline of everything that happened in a project.

But implementing it meant:

Redesigning the feed data model
Creating a new filtering system
Building a completely different UI
Making it performant with thousands of items

Too risky. Too expensive. We kept putting it off.

Then Claude Code built the first version in 90 minutes. We tried it. Iterated. Shipped it two days later.

History became one of our best features. And it only exists because trying it became cheap.

2. AI That Understands Your Work

We knew we wanted AI in Bonjour. But we didn't know how.

So we tried everything:

A chatbot that lived in a sidebar (too isolated)
An assistant that summarized your feed (too passive)
A command palette with AI actions (too hidden)
An inline assistant that suggested next steps (too intrusive)

Each experiment took 30-60 minutes. We tried a dozen different approaches in a single week.

The version we shipped? It was attempt #8. We never would have gotten there the old way.

3. Notes as First-Class Citizens

Originally, notes were just "descriptions" on tasks. An afterthought.

But during a refactor, Claude Code suggested: "What if notes were their own model?"

That sounded like a massive change. But Claude could handle it, so we said "sure, try it."

90 minutes later, notes were first-class. You could create notes without tasks. Link multiple tasks to one note. Build entire threads of thinking.

It transformed how Bonjour works. And we almost didn't try it because it "sounded too hard."

The Fear We Lost

Here's what's hard to explain if you haven't experienced it:

Coding with AI isn't just faster. It's less scary.

Before: "I could refactor this, but what if I break something?"

Now: "Let's refactor it. If it breaks, we'll fix it. Or roll it back and try a different approach."

That psychological shift—from "I can't afford to be wrong" to "being wrong is fine"—unlocked a level of creativity we'd never had before.

What About "Understanding Your Code"?

The common criticism: "But you won't understand what the AI wrote!"

And honestly? Sometimes that's true.

But here's the thing: I already didn't understand half my code. Because I wrote it 8 months ago and forgot why I made certain decisions.

With AI, at least the code is well-commented, tested, and documented. Often better than what I would have written manually.

Plus, when you work alongside AI:

You review every change before committing
You guide the high-level decisions
You learn patterns from what it generates
You understand the "why" because you set the direction

It's collaboration, not delegation.

The Downside

I'd be lying if I said there were no downsides.

The code is less "mine." There's something satisfying about writing a feature from scratch. I miss that sometimes.

Bad ideas ship faster. When experimentation is cheap, you try more things. Some of them are terrible. You have to be disciplined about saying "no, this didn't work."

Dependency risk. If Claude Code or Cursor disappeared tomorrow, our velocity would drop significantly. That's scary.

But even with those downsides? I'd never go back.

What This Means for Bonjour

Here's why this matters beyond just "we built faster."

Because experimentation became cheap, we could afford to be more opinionated.

We tried 12 different approaches to AI integration. We tried 8 different layouts for history. We tried 4 different ways to handle real-time updates.

And we picked the ones that aligned with our philosophy—not the ones that were "easiest to implement."

AI coding didn't just make us faster. It made us better at building what we believed in.

The Meta Point

There's something poetic about this:

We built a tool to help teams make history—to document context, decisions, and thinking.

And we built it using AI that made experimenting with context, decisions, and thinking actually practical.

The tool shaped the product. The product reinforced the tool.

Next: Making Notes and History Meaningful