Neuvottelija.com

2026-07-15 · AI Lab · Insight

From Vibe Coding to Agentic Engineering

A year ago on this podcast, “vibe coding” was still a punchline — the idea that anyone could describe a website in plain language and watch it materialize, no computer-science degree required. Listening back to two conversations recorded roughly three months apart, I can hear the ground shifting under that punchline in real time. By the second conversation, the guest wasn’t talking about typing prompts into a chat box anymore. He was talking about memory architecture, kanban boards for AI agents, and training bots the way you’d train new hires. Same underlying technology, radically different posture toward it. That’s the arc I want to trace here: from vibe coding to what I’d now call agentic engineering.

What vibe coding actually unlocked

In Vibe-koodaus, my conversation with Lasse Mikkonen and Harri Juntunen of AI Kanava, the excitement was almost entirely about a gap collapsing — the distance between having an idea and having something running. Mikkonen described building a website with the tool Lovable in about an hour — a project he’d earlier spent roughly six months struggling with alongside a couple of students, doing it by hand in HTML and WordPress. Juntunen, from the product-lifecycle side, put the underlying shift in blunter terms: software, he argued, has always been a giant brake between the question, the idea, and the data — and that friction is now melting away, putting people in much more direct contact with their own data than any menu-driven interface ever allowed.

That friction reduction showed up everywhere in the conversation. Sales meetings that used to end with a static PowerPoint now end with a working prototype the customer can react to on the spot. A four-day side project let Juntunen build his own CRM-style tool for navigating Slush instead of fighting an unwieldy conference platform. And DevOps pipelines — the scripts, containers, and test suites that used to require specialist knowledge of Linux, GitHub Actions, and Docker — became, in Mikkonen’s telling, almost trivial for AI to assemble, since they’re really just a few dozen lines stitched together. He pushed the point further: testing used to be a compromise, with teams covering maybe 20% of features because nobody had time to write the rest of the test cases; now, he argued, near-complete test coverage is within reach because the AI writes the cases.

The failure modes nobody mentions in the demo

But both guests were equally candid about where this breaks. Juntunen described chasing a database bug through version control, pulling in code from an earlier working state, and discovering the bug wasn’t even in the code he was staring at — it was a permissions setting an AI tool had quietly flipped on. He named the deeper pattern: “when it might come up with some solution, it could be any kind of messy code that is totally different from the previous version, so the development history can be very random” (24:32). That randomness compounds: ask an agent to fix a bug that’s actually your own bad test input, and it will happily rewrite 150 lines of working code chasing a phantom.

There’s also a governance problem hiding under the excitement, one I think gets too little airtime. Mikkonen and Juntunen described an organization that had learned to trust a model’s outputs, only to have the underlying model updated overnight with no continuity — the tone changed, the answers changed, and the team had no idea why until they traced it back to a silent upgrade. Their framing has stuck with me since: it’s “like a smart summer trainee or a dumb summer trainee. The only thing is, it might change overnight to be a bit smarter or less smart” (41:02). You don’t manage that with more enthusiasm. You manage it the way Mikkonen suggested thinking about the whole discipline — not as automation replacing judgment, but as partnership: “I think you should think about these a bit like a centaur, where machine and human are joined together” (36:56). Autonomy and control sit on a spectrum, and where you set the dial depends on whether you’re prototyping for a sales meeting or touching a bank’s mainframe — a distinction both guests insisted on. Nobody wanted to vibe-code money movement.

Agentic engineering: memory, loops, and intent

Three months later, in Tekoälykoodaus huipputasolla, Markus Hav — Hoxhunt’s in-house AI practitioner — described a much more deliberate discipline built on top of the same base. His starting point was the context window itself: the finite amount of text a model can actively hold, which has grown from an 8,000-token GPT-era ceiling to today’s million-token windows, but which still has to be managed like memory, not treated as infinite. Emptying it, summarizing it, deciding what gets carried forward — that management problem is, in Hav’s telling, most of what separates a competent agent from a flailing one.

His favorite illustration was a technique he calls the Ralph Wiggum loop, named for the Simpsons character who says “I’m helping.” Instead of building elaborate multi-agent orchestras to keep a huge, ever-expanding memory coherent, you do close to the opposite: give the agent a task list, let it wipe its own memory after finishing each item, and let it grind through the list from a clean slate every time. Hav’s summary: “the idea is that this isn’t, like, about orchestration and multiple runs — an endless context window isn’t the point, but rather the opposite: you give it a kind of kanban board, or a task list… and you reset with this kind of basic loop.” The payoff, delivered the next morning: “You didn’t need a goddamn orchestra, just this kind of idiot” (15:32).

The other half of Hav’s discipline is what he calls “codumentation” — turning documentation into something closer to runnable specification, so an agent (or a junior coder, or a Ralph loop) has hard boundaries it genuinely cannot cross. He arrived at this after wrestling with whether code even matters anymore next to the underlying intent. His answer: documentation and specification are not the same thing, and getting the spec right changes everything. “You need the spec, that documentation and a spec are different things, but if you have it well-specced… it’s more than half done — especially in this current era” (37:17).

And then there’s security, which Hav approaches through his day job at a human-risk-management company, not as an afterthought. His diagnosis is that the entire discipline needs to be rebuilt from different assumptions. Traditional security scopes access tightly — you know exactly what you want a system to do and you grant exactly that much. Agentic AI inverts the incentive: “the whole idea of AI is that the more data you give it, and the more agency you give it, the more, the more it’s able to do. But traditionally, security never, ever works that way — instead you know what you want and you scope your task to exactly that much” (06:12). That tension — usefulness scales with access, but security scales with restriction — doesn’t resolve itself. It has to be managed deliberately, staged, sandboxed, tested.

The team implication: unlearning beats experience

The most counterintuitive claim across both conversations was about who benefits most. Hav argued for what he called a “small-mover edge”: people who haven’t accumulated years of fixed habits pick up AI-assisted workflows faster than veterans who have to unlearn a way of working first. Inside his own organization at Hoxhunt, he’d noticed the pattern directly — new hires and people switching roles, arriving with something close to a clean context window, got more out of the AI tools than colleagues who’d always done things a certain way and now had to unlearn it first. Mikkonen’s practical advice ran parallel to this: get an IT department to demo vibe coding to the rest of the team, or bring in a consultant for a hands-on session, because a few tens of euros a month buys more learning bandwidth than most companies expect.

Where I land

I recognize both halves of this arc in my own habits, and I’ve deliberately kept myself on the frugal end of it — I run Claude Code on the roughly hundred-euro tier while Hav has spent up to €400 a month, and I don’t chase every new release the moment it ships. I’ve also started wiping my own Claude.md files clean rather than dragging forward what I admitted, on air, was frankly garbage my younger self had written back in December. That’s the same instinct as the Ralph Wiggum loop, applied to my own second brain: a clean slate beats an accumulated mess. I’ve tested this stuff hands-on rather than theorized about it — running Claude for Excel and Claude Cowork myself against work I’d originally done years ago on the Translink team, and watching how much better the same task goes now. The tools keep changing faster than anyone can fully track, and I’ve made peace with that: you pick your battles, you stay oriented toward where things are heading, and you accept that the next six months will probably upend today’s best practice anyway.

Source episodes

Every claim in this essay is grounded in the following episodes; quotes carry timestamps linking to the original video. English subtitles and full transcripts are on each episode page.

← AI Lab · Markdown mirror: index.md