Code Lixi

Everyone posts about projects that went right.

A client almost fired us in March.

Not because we missed a deadline.

Not because the code was broken.

Because we kept agreeing with them.

Six weeks into a $55K project.

Every weekly call:

Client: "Can we add this feature?"
Us: "Sure, we can make that work."

Client: "Can we change this flow?"
Us: "Absolutely, no problem."

Client: "Can we expand this section?"
Us: "Of course."

Week six: 340% scope increase.

Same budget.
Same deadline.

We had a choice.

Keep agreeing and deliver something broken.
Or have the conversation we'd been avoiding for six weeks.

We chose the conversation.

Told them the truth:

"We've agreed to everything you've asked for. That was our mistake. What you've described now would take 4 months and $140K to build properly. We're 6 weeks in and have $55K. We need to decide together what we're actually building."

Silence on the call.

Then:
"Why didn't you tell us this three weeks ago?"

We didn't have a good answer.
We rebuilt the scope together.

Cut 60% of the features.
Built the core product in 5 weeks.
Launched on the original deadline.

Client called it their best product launch.

The 60% we cut?

They came back two months later with clear requirements and a new budget.
That became a $38K follow-on project.

The most expensive thing we do isn't building software.

It's staying quiet when we should speak up.

We're still learning that lesson.

What's the hardest truth you've had to tell a client?

We almost shipped broken code last month.

Not a client's project.
Ours.

We were rebuilding our internal project management tool.

Deadline pressure. Lean team. Used AI to move faster.

The code looked clean. Reviews felt smooth. We shipped.

Three days later our ops manager messaged at 7 AM:

"Something's wrong. Data isn't syncing between projects."

We opened the codebase.
The AI had generated a sync function that worked perfectly in isolation.
Nobody had tested what happened when three projects ran simultaneously.

We hadn't either.

Four hours of emergency fixes. Two client updates delayed. One very uncomfortable Monday standup.

Here's what we didn't expect.

The bug wasn't the worst part.
The worst part was realising we'd reviewed every individual function and missed the system entirely.

We were checking lines of code.
Nobody was checking behaviour.

We rebuilt our review process that week.
Now every AI-generated function gets tested in context, not just in isolation.

Sounds obvious.
We needed a broken Monday to actually do it.

96% of developers distrust AI-generated code.
46% of new code being written is AI-generated.

That gap isn't a statistic.

It's a Monday morning waiting to happen.

When did you last test your system, not just your code?

We weren't happy by charged premium rates for AI-powered development last year.

Clients were happy.

Every time a client called back for changes, we'd open the codebase.

And feel something we never felt during the build.

Dread.

AI made decisions we didn't fully review.

Nobody documented why.

Six months later — including us — nobody could explain it.

The code worked.

We just couldn't own it.

One client asked us something that ended that era completely:

"If your team disappeared tomorrow, could another developer pick this up?"

We said yes.

We weren't sure we meant it.

That was the last project we built that way.

Now every AI-generated function has a human who can explain it.

Every decision is documented.
Every handover is something the client genuinely owns.

It costs us speed.

It costs us clients who want cheap and fast.

We've never been more certain we're doing it right.

Most agencies building this way won't admit it.

If yours can't explain every decision their AI made on your project, you don't own your software.

You're renting a problem.

"Can you just build what we're asking for?"

A prospect asked us this yesterday after 30 minutes of questions.

Prospect: "We need a custom CRM. Budget is $85K."

Us: "Have you tried Salesforce?"

Prospect: "Too expensive."

Us: "Salesforce is $15K/year. Custom is $85K. How is Salesforce too expensive?"

Prospect: "Well... it doesn't do exactly what we need."

Us: "What specifically?"

Prospect: "We haven't actually tried it."

Here's what we said:

"Try Salesforce first. If it doesn't work, come back. You'll know exactly what custom needs to do differently."

Prospect: "So you're telling me NOT to hire you?"

Us: "We're telling you to spend $15K before spending $85K."

They hung up. We assumed we lost the deal.

This morning they called back.

Salesforce did 80% of what they needed.

New project: $12K integration (not $85K full build)

They saved: $58K
We "lost": $73K
We gained: A client who trusts us + 2 referrals already

The best marketing isn't how much you charge.

It's how much you're willing to NOT charge when it's the right call.

What's one time a vendor talked you out of buying and you trusted them more?

This conversation happens at least once a week.

Client: "Can you build us a custom analytics dashboard?"
Us: "Maybe. Can I ask three questions first?"
Client: "Sure."

Us: "Who asked for this?"
Client: "Our VP of Sales saw a competitor's dashboard and wants something similar."

Us: "What happens if you don't build it?"
Client: "We might lose deals because our data isn't as impressive."
Us: "Have you lost any deals because of this?"
Client: "Well... not that we know of."

Us: "How will you know it's working?"
Client: "I guess... more closed deals?"
Us: "How many more deals would justify the $60K investment?"
Client: [pause] "We haven't calculated that."

One of two things happens next:

→ They realize they don't actually need it.
→ They come back with a clearer problem.

Last month, a client came back after this exact conversation.

Instead of asking for a custom dashboard, they said:

"We realized our problem isn't visualization. It's that our sales team and analytics team use different definitions of 'qualified lead.' Can you build something that syncs those definitions?"

Cost: $12K instead of $60K
Timeline: 2 weeks instead of 3 months
Result: 3 more closed deals in the first month

Here's our philosophy:

Most software agencies ask: "What do you want us to build?"
We ask: "What problem are you trying to solve?"

The first question makes us order-takers.
The second makes us partners.

Before we write any code, we ask three questions:

1. Who's asking for this? (Customer pain or internal opinion?)
2. What happens if we don't build it? (Real cost or hypothetical risk?)
3. How will you know it's working? (Clear metric or vague hope?)

If the answers are vague, we push back.

Not because we don't want the project.
Because we don't want to build something that fails.

The best code is code you don't have to write.
The best projects start with the right questions.

What's one project you wish someone had questioned before you started?