Ivan Turkovic

Imagine standing in front of a freshly picked cocoa pod. You break it open, and inside you find a pale, sticky pulp with bitter seeds. Nothing looks edible, nothing smells particularly appetizing. By every reasonable measure, this is a dead end.

Yet humanity somehow didn’t stop there. Someone, centuries ago, kept experimenting, steps that made no sense at the time:

• Picking out the seeds and letting them ferment until they grew mold.
• Washing and drying them for days, though still inedible.
• Roasting them into something crunchy, still bitter and strange.
• Grinding them into powder, which tasted worse.
• Finally, blending that bitterness with sugar and milk, turning waste into one of the most beloved foods in human history: chocolate.

No algorithm would have told you to keep going after the first dozen failures. There was no logical stopping point, only curiosity, persistence, and maybe a bit of luck. The discovery of cocoa as food wasn’t the result of optimization, it was serendipity.

Why This Matters for AI

AI today is powerful at recombining, predicting, and optimizing. It can remix what already exists, generate new connections from vast data, and accelerate discoveries we’re already aiming toward. But there’s a limit: AI doesn’t (yet) explore dead ends with stubborn curiosity. It doesn’t waste time on paths that appear pointless. It doesn’t ferment bitter seeds and wait for mold to form, just to see if maybe, somehow, there’s something new hidden inside.

Human discovery has always been messy, nonlinear, and often illogical. The journey from cocoa pod to chocolate shows that sometimes the only way to find the extraordinary is to persist through the ridiculous.

The Future of Discovery

If we want AI to go beyond optimization and into true discovery, it will need to embrace the irrational side of exploration, the willingness to try, fail, and continue without clear reasons. Until then, AI remains a tool for extending human knowledge, not replacing the strange, stubborn spark that drives us to turn bitter seeds into sweetness.

Because the truth is: chocolate exists not because it was obvious, but because someone refused to stop at “nothing edible.”

This path makes no sense. At every step the signal says stop. No data suggests you should continue. No optimization algorithm rewards the action. Yet someone did. And that’s how one of the world’s favorite foods was discovered.

This is the gap between human discovery and AI today.

AI can optimize, remix, predict. It can explore a search space, but only one that’s already defined. It can’t decide to push through meaningless, irrational steps where there’s no reason to keep going. It won’t follow a path that looks like failure after failure. It won’t persist in directions that appear to lead nowhere.

But that’s exactly how discovery often works.

Cocoa to chocolate wasn’t about efficiency. It was curiosity, stubbornness, and luck. The same applies to penicillin, vulcanized rubber, even electricity. Breakthroughs happen because someone ignored the “rational” stopping point.

AI is far from that. Right now, it’s bounded by what already exists. It doesn’t yet invent entirely new domains the way humans stumble into them.

The lesson? Discovery is still deeply human. And the future of AI will depend not just on making it smarter, but on making it willing to walk blind paths where no reward signal exists until something unexpected emerges.

Because sometimes, you need to go through moldy seeds and bitterness to find chocolate.

Building a startup is a race against time. Every day you wait to ship your idea is a day your competitors could gain an edge. That’s why many founders start with freelancers or “vibe coding” to launch their MVP (Minimum Viable Product) quickly. But this fast-track approach comes with hidden risks. There comes a point when hiring real engineers is no longer optional, it’s critical for your startup’s survival.

In this post, we’ll explore when it’s the right time to transition from freelancers to full-time engineers, and why vibe coding with low-cost freelancers can be dangerous for your MVP.

Why Start With Freelancers?

Freelancers are often the first choice for early-stage founders. Here’s why:

• Speed: Freelancers can help you quickly prototype your idea.
• Lower Cost: You pay for work done, without the overhead of full-time salaries or benefits.
• Flexibility: You can scale the workforce up or down depending on the project stage.

Freelancers are perfect for validating your idea, testing market demand, or building proof-of-concept features. However, relying on freelancers too long can create technical debt and slow your growth when your product starts attracting real users.

The Hidden Dangers of Vibe Coding With Low-Cost Freelancers

Many founders are tempted by freelancers offering extremely low rates. While the idea of saving money is appealing, vibe coding with bargain-rate developers comes with serious risks:

• Poor Code Quality: Low-cost freelancers may cut corners, leaving messy, unmaintainable code.
• Lack of Documentation: Your codebase may be difficult for future engineers to understand or build upon.
• Delayed Timelines: Cheap freelancers often juggle multiple clients, causing unpredictable delays.
• False Confidence: Founders may assume their MVP is “production-ready” when it’s not.
• Hidden Costs: Fixing technical debt later often costs more than hiring quality engineers from the start.

Using low-cost freelancers is fine for prototyping ideas quickly, but it becomes risky when your MVP starts attracting real users or paying customers.

Signs You Need Real Engineers

Here are the main indicators that your MVP has outgrown freelancers:

1. Product Complexity Increases

• Your MVP is no longer a simple prototype.
• Features require backend scalability, integrations, or complex logic.
• Codebase is hard for freelancers to maintain consistently.

2. Customers Expect Stability

• Paying users begin using your product regularly.
• Bugs, downtime, or inconsistent updates start hurting your credibility.
• You need reliable, professional code that can scale.

3. You Plan for Rapid Growth

• You anticipate increasing traffic, user engagement, or data volume.
• Your MVP needs a scalable architecture to handle more users efficiently.

4. Security and Compliance Matter

• Sensitive user data, payment systems, or regulatory requirements are involved.
• Freelancers may lack the expertise to ensure security best practices.

How to Transition Smoothly to Full-Time Engineers

Once you’ve decided to hire real engineers, plan the transition carefully to avoid disruption:

1. Audit Existing Code: Identify areas of technical debt and create a roadmap for refactoring.
2. Hire Strategically: Look for engineers with startup experience who can handle rapid iteration and product scaling.
3. Document Everything: Ensure all features, APIs, and infrastructure are well-documented for the new team.
4. Maintain Continuity: Keep a few top freelancers for short-term tasks during the handover period.
5. Invest in Tools: Use code repositories, CI/CD pipelines, and testing frameworks to support professional development practices.

Cost Considerations

Hiring full-time engineers is an investment. While freelancers may seem cheaper upfront, consider the long-term costs:

• Technical Debt: Fixing poor-quality code can cost far more than hiring engineers initially.
• Lost Customers: Product instability can lead to churn and missed revenue.
• Opportunity Cost: Delays in scaling and adding features can let competitors win market share.

Think of full-time engineers as insurance for your product’s future success.

Conclusion

Freelancers are invaluable for testing your idea and building a lean MVP quickly. But relying on low-cost vibe coding can be dangerous: messy code, delayed timelines, and hidden costs can stall your startup before it even takes off. Once your product gains traction, complexity, and paying users, hiring real engineers ensures stability, scalability, and long-term growth.

Key Takeaway: Use freelancers for prototyping, but transition to full-time engineers before your MVP becomes a product your customers depend on. Planning the move carefully saves time, money, and frustration.

Have you experienced the vibe code tax firsthand? Share your story in the comments and tell us how you decided when to hire full-time engineers.

Over the past two years, I’ve been using various AI-assisted tools for programming like Codeium, GitHub Copilot, ChatGPT, and others. These tools have become part of my daily workflow. Mostly, I use them for code completion and to help me finish thoughts, suggest alternatives, or fill in repetitive boilerplate. I’m not doing anything too wild with autonomous agents or fully automated codebases. Just practical, incremental help.

That said, even in this limited use, I’m starting to feel the friction.

Not because the tools are bad but actually, they’re improving fast. Individual lines and even complete methods are cleaner than they used to be. The suggestions are smarter. The models are more context-aware. But one thing still nags at me: even with better completions, a lot of the output still isn’t good code in the long-term sense.

Maintainability Still Matters

The issue, to me, isn’t whether AI can help me write code faster. It can. The issue is whether that code is going to survive over time. Is it going to be easy to understand, extend, or refactor? Does it follow a style or pattern that another human could step into and build on?

This matters especially when you’re not the only one touching the code or when you come back to it after a few months and wonder, “Why did I do it this way?”

And here’s the contradiction I keep running into: AI helps you write code faster, but it often creates more problems to maintain. That’s especially true when I’ve tested more advanced setups where you let an agent plan and generate entire components, classes, or services. It sounds great in theory, but in practice it causes a lot of changes, inconsistencies, and small bugs that end up being more trouble to fix than if I had just written it myself from the start.

So for now, I stay close to completions. Code at the scale of a line or a method. It’s easier to understand, easier to control. I can be the architect, and the AI can be the assistant.

The Self-Fulfilling Trap

There’s a strange loop forming in AI development. Since the generated code is harder to reason about or maintain, people often treat it as throwaway. And because it’s throwaway, nobody bothers to make it better. So it stays bad.

Self-fulfilling prophecy.

The more AI you use to generate logic, the more you’re tempted to not go back and polish or structure it. You get into a loop of “just generate something that works,” and soon you’re sitting on a pile of glue code and hacks that’s impossible to build on.

But maybe that’s okay? Maybe we need to accept that some code isn’t meant to last.

Disposable Software Might Be the Point

This is where I’m starting to shift my thinking a little. I’ve always approached code as something you build on something that lives and evolves. But not all code needs that.

A lot of software today already is disposable, even if we don’t admit it. One-off internal dashboards, ETL jobs, scripts for events, MVPs for marketing campaigns, integrations that won’t live beyond a quarter. We often pretend we’re building maintainable systems, but we’re not. We just don’t call them disposable.

With AI in the mix, maybe it’s time to embrace disposability for what it is. Write the code, run the code, get the result, throw it away. Next time, generate it again maybe with better context or updated specs.

This mindset removes a lot of the pressure around maintainability. And it fits the strengths of today’s AI tools.

When Not to Use Agentic Systems (Yet)

I’ve played with more autonomous agent systems what people call “agentic AI” or multi-agent code platforms. Honestly? I’m not sold on them yet. They generate too much. They make decisions I wouldn’t make. They refactor things that didn’t need to be touched.

And then I spend more time reading diff views and undoing changes than I saved by delegating in the first place.

Maybe in the future I’ll be comfortable letting an AI agent draft a service or plan out an architectural pattern. But today, I’m not there. I use these tools more like smart autocomplete than autonomous developers. It’s still very much my code and they’re just helping speed up the flow.

Final Thoughts

There’s a real risk of overhyping what AI can do for codebases today. But there’s also an opportunity to rethink how we treat different classes of software. We don’t need to hold everything to the same standards of longevity. Not every project needs to be built for 10 years of feature creep.

Some software can (and should) be treated like scaffolding and built quickly, used once, and removed without guilt.

And that’s where AI shines right now. Helping us build the things we don’t need to keep.

I’ll keep experimenting. I’ll keep writing most of my own code, and using AI where it makes sense. But I’m also watching carefully because the balance between what’s worth maintaining and what’s better thrown away is shifting.

And we should all be ready for what that means.

Large Language Models (LLMs) like ChatGPT, Copilot, and others are becoming a regular part of software development. Many developers use them to write boilerplate code, help with unfamiliar syntax, or even generate whole modules. On the surface, it feels like a productivity boost. The work goes faster, the PRs are opened sooner, and there’s even time left for lunch.

But there’s something underneath this speed, something we’re not talking about enough. The real issue with LLM-generated code is not that it helps us ship more code, faster. The real issue is liability.

Code That Nobody Owns

There’s a strange effect happening in teams using AI to generate code: nobody feels responsible for it.

It’s like a piece of code just appeared in your codebase. Sure, someone clicked “accept,” but no one really thought through the consequences. This is not new, we saw the same thing with frameworks and compilers that generated code automatically. If no human wrote it, then no human cares deeply about maintaining or debugging it later.

LLMs are like that, but on a massive scale.

The “Average” Problem

LLMs are trained on a massive corpus of public code. What they produce is a kind of rolling average of everything they’ve seen. That means the code they generate isn’t written with care or with deep understanding of your system. It’s not great code. It’s average code.

And as more and more people use LLMs to write code, and that code becomes part of new training data, the model quality might even degrade over time, it becomes an average of an average.

This is not just about style or design patterns. It affects how you:

• Deliver software
• Observe and monitor systems
• Debug real-world issues
• Write secure applications
• Handle private user data responsibly

LLMs don’t truly understand these things. They don’t know what matters in your architecture, how your team works, or what your specific constraints are. They just parrot what’s most statistically likely to come next in the code.

A Fast Start, Then a Wall

So yes, LLMs speed up the easiest part of software engineering: writing code.

But the hard parts remain:

• Understanding the domain
• Designing for change
• Testing edge cases
• Debugging production issues
• Keeping systems secure and maintainable over time

These are the parts that hurt when the codebase grows and evolves. These are the parts where “fast” turns into fragile.

Example: Generated Code Without Accountability

Imagine you ask an LLM to generate a payment service. It might give you something that looks right, maybe even works with your Stripe keys or some basic error handling.

But:

• What happens with race conditions?
• What if fraud detection fails silently?
• What if a user gets double-charged?
• Who is logging what?
• Is the payment idempotent?
• Is sensitive data like credit cards being exposed in logs?

If no one really “owned” that code because it was mostly written by an AI and these questions might only surface after things go wrong. And in production, that can be very costly.

So What’s the Better Approach?

LLMs can be great tools, especially for experienced engineers who treat them like assistants, not authors.

To use LLMs responsibly in your team:

• Review AI-generated code with care.
• Assign clear ownership, even for generated components.
• Add context-specific tests and documentation.
• Educate your team on the why, not just the how.
• Make accountability a core part of your development process.

Because in the end, you are shipping the product. The AI isn’t going to be on call at 2 AM when things go down.

Final Thoughts

LLMs give us speed. But they don’t give us understanding, judgment, or ownership. If you treat them as shortcuts to ship more code, you may end up paying the price later. But if you treat them as a tool and keep responsibility where it belongs they can still be part of a healthy, sustainable development process.

Thanks for reading. If you’ve seen this problem in your team or company, I’d love to hear how you’re dealing with it.

We were told that AI would make development more accessible. That it would “level the playing field,” empower juniors, and help more people build great software.

That’s not what I’m seeing.

In reality, AI is widening the gap between junior and senior developers and fast.

Seniors Are 10x-ing With AI

For experienced engineers, AI tools like ChatGPT and GitHub Copilot are a multiplier.

Why?

Because they know:

• What to ask
• How to evaluate the answers
• What matters in their system
• How to refactor and harden code
• When to ignore the suggestion completely

Seniors are using AI the same way a great chef uses a knife: faster, safer, more precise.

Juniors Are Being Left Behind

Many junior developers, especially those early in their careers, don’t yet have the experience to judge what’s good, bad, or dangerous. And here’s the issue:

AI makes it look like they’re productive until it’s time to debug, optimize, or maintain the code.

They’re often:

• Copy-pasting solutions without understanding the trade-offs
• Relying on AI to write tests they wouldn’t know how to write themselves
• Shipping code that works on the surface, but is fragile underneath

What they’re building is a slow-burning fire of tech debt, and they don’t even see the smoke.

Prompting Isn’t Engineering

There’s a new kind of developer emerging: one who can write a great prompt but can’t explain a stack trace.

That might sound harsh, but I’ve seen it first-hand. Without a foundation in problem-solving, architecture, debugging, and security prompting becomes a crutch, not a tool.

Good engineering still requires:

• Judgment
• Pattern recognition
• Systems thinking
• Curiosity
• Accountability

AI doesn’t teach these. Mentorship does.

Where Is the Mentorship?

In many teams, mentorship is already stretched thin. Now we’re adding AI to the mix, and some companies expect juniors to “just figure it out with ChatGPT.”

That’s not how this works.

The result? Juniors are missing the critical lessons that turn coding into engineering:

• Why things are built the way they are
• What trade-offs exist and why they matter
• How to debug a system under load
• When to break patterns
• How to think clearly under pressure

No AI can give you that. You only get it from real experience and real guidance.

What We Can Do

If you’re a senior engineer, now is the time to lean into mentorship not pull away.

Yes, AI helps you move faster. But if your team is growing and you’re not helping juniors grow too, you’re building speed on a weak foundation.

If you’re a junior, use AI but don’t trust it blindly. Try to understand everything it gives you. Ask why. Break it. Fix it. Learn.

Because here’s the truth:

AI won’t make you a better engineer. But it will make great engineers even better.

Don’t get left behind.

Final Thoughts

AI isn’t the enemy. But it’s not a shortcut to seniority either. We need to be honest about what it’s good for and where it’s failing us.

Let’s stop pretending it’s a magic equalizer. It’s not.

It’s a magnifier.
If you’re already strong, it makes you stronger.
If you’re still learning, it can hide your weaknesses until they blow up.