FrontKon#26: Code Gets Cheaper, Responsibility Doesn’t

On October 6, we headed to FrontKon 2026, and it was immediately clear what ruled this year: AI agents. But the talks we enjoyed most weren’t about how to write more code in less time. They were about who is accountable for the result, how to tell that the work is really done, and when plain, predictable code should step in instead of a model.

Below you’ll find what we’re taking back to our team from the conference, the talks we saw, and the ideas that kept coming up in them. The full program is at frontkon.tech.

What We’re Taking Back to Our Team

• An AI summary of Sentry errors in Slack. We already partly have something similar, and after Jan Kaiser’s talk we want to take it further: code prepares the data, the model writes the summary, and the errors arrive sorted by severity.
• A screenshot or video with every PR from an agent. Some of us already do this, and we’d like to make it a standard part of our definition of done.
• Thinking about performance from the start. Agreeing with the client and the designers on what the website can handle before the designs get approved.
• Cleaning up dead code (old flags, unused components) in CI. A bot suggests, a human reviews.
• Using Robin’s autonomy matrix in planning: AI as an assistant for the client’s core domain, while supporting and clear parts can go fully to agents.

Everyone Wants a Fast Website. Until They Have to Remove Something

Martin Kocourek, David Maixner

When Sazka was rebranding to Allwyn, its website kept crashing on iPhones. The culprit was thousands of compositing layers: videos in product cards, piles of shadows, overlays, and badges, plus about 20 carousels built on a JS library.

The developers couldn’t fix it on their own, because the problem was baked into the already approved design. What finally helped was getting everyone involved: the business set priorities, editors swapped videos for static images, the designers took part in a workshop, and the developers replaced the carousels with native scrolling. Out of 3,709 layers, only 422 were left, and the website stopped crashing even on the weakest devices.

We couldn’t agree more. A fast website isn’t a job just for developers. It takes business, design, and development together.

Frameworks Are Not Enough: The Future Stack for AI Development

Petr Glaser

Petr goes through roughly 50 billion tokens a month. In his view, what agents lack most is being told clearly when the work is done. His recommendations:

• Fast tooling. Slow tools like Webpack or ESLint hold the agent back and eat into the CI budget. Use oxfmt, oxlint, and Rstest instead.
• Rules, not requests. Linters (oxlint, the Ultracite preset), knip for dead code, jscpd for duplicates. Today, even an agent can write custom lint rules, so whatever now lives in AGENTS.md should gradually become an automated check.
• Types that show errors. Effect shows right in the type how a function can fail, and adds tracing.
• Company know-how in the repo. Turn the history of commits and reviews into skills for agents.
• Proof that it’s done. The agent attaches check results, a review from another agent, a screenshot, or a video to the PR.

We Stopped Reading Logs – But We Still Fix Issues Before Users Notice

Jan Kaiser

Every day, Jan spent half an hour going through logs in New Relic by hand, and there were plenty of them: up to 350,000 a day. So he “vibe-coded” a tool to do it for him, based on his older reports from Slack.

The first version wasn’t much good. Two feedback loops improved it: during development, the agent received Jan’s corrections to the reports, and in production, the tool reads how the team reacts to the reports in Slack and keeps a history (JSON in S3).

Most of the work is done by plain code: it fetches the data, clusters it, and sorts it based on that history. The model only assesses individual issues and writes the summary. If the model fails, the report still arrives, just in a stripped-down form. One run takes 18 model calls and costs about $0.16, which comes to less than $5 a month. It saves a senior developer about 10 hours a month and has already uncovered real bugs, such as a customer stuck in checkout.

AI Made Every Developer a Tech Lead. Now What?

Robin Pokorný

Code is getting cheaper fast, and there are now 15 people for every engineering manager (SignalFire, State of Talent 2026). Robin concludes that every developer now needs tech lead skills: writing up requirements, weighing trade-offs, having a vision, and keeping an eye on risks (Patrick Kua’s Trident model).

Our biggest takeaway was his matrix showing how much autonomy to give AI depending on the type of domain:

Robin wrapped up with the line “Strong tech leads are made, not hired.” You simply have to grow them yourself.

Panel: Agent-Based Development in Practice

Sylwia Laskowska, Petr Glaser, Kamil Tomšík

The panelists agreed that agents can handle most of the coding, but decisions, and judging whether the work is really done, remain with people. And what should you tell people who don’t review AI code even in production? “Visual PR”: show the change, don’t just describe it.

What if AI gets more expensive? For now, one of the panelists is letting investors foot the bill, but he’s preparing: he saves all his Codex logs (about 100 GB of text) so he can later fine-tune a smaller model on his own libraries. Sylwia Laskowska took a pragmatic view: the company pays for the tokens. And if AI got much more expensive, companies might start hiring juniors again for simpler work.

Do you miss writing code? Here the answers split. One panelist misses “artisan” code, but as a tech lead he’s glad that machines handle the routine. Another doesn’t miss it at all: he can write in Rust or in formal verification languages that nobody wants to read (agents do), and focus on the product himself. The third misses it, as he spent 18 years getting better at it. But what matters is delivering and knowing what’s going on, so everyone should do reviews. Today he feels more like a manager of agents, and he thinks the same is in store for most of us.

Outlook for the next 6–12 months: more companies will move to local models, because their drawbacks are quickly disappearing. Three layers will become the norm: a model on the device, one in the company tenant (such as Azure), and one in the cloud. More work will go to cheaper models, but nothing can replace the cloud ones yet. And as a bonus, SSD prices will shoot up.

Panel: The Present and Future of Work in IT

Markéta Krejčí, Libor Vaněk, Petr Burian

The job market panel was surprisingly optimistic. Some companies are hiring by the hundreds again, there’s plenty of talent on the market, and the whole shift is happening more slowly than expected.

Juniors. According to the panel, now is a great time to be a junior. A curious person can learn anything with AI and stand out quickly. Companies are looking for curiosity, a willingness to learn, and above all the ability to tell what matters. IBM has reportedly announced that it will hire more juniors so that it has seniors in five years. Markéta Krejčí from HR advised including a personal project in your CV and sticking to the wording of the job ad, because CVs are now often screened by AI tools first and recruiters look for exact terms. And one thing that applies to everyone: we’ve only been working with AI at full speed for about half a year, so in a way, we’re all juniors at this.

Small teams. Libor Vaněk of CDN77 has been betting on small, focused teams for ten years. With every additional person, complexity grows and efficiency drops. AI simply fit into that, and they didn’t have to lay anyone off. Startups really are managing more with smaller teams: one shrank from 18 people to 8 and is still hitting its targets. One question remained open: is AI the real reason behind big layoffs, or just an excuse? According to the panel, what matters is a short lead time and as few handoffs between people as possible. Whoever ships lots of features quickly has a better chance of hitting the one that makes money.

AI fatigue. There used to be a new framework every two months; now there’s a new model every week. The advice from the stage: choose what to work on based on the value it brings, not on what’s trending on Forbes. And don’t forget to look after your mental well-being.

Money. The panel doesn’t see salaries falling yet. But agencies are offering fewer permanent positions and more body shopping, where high day rates come at the cost of uncertainty. People get paid for being able to solve complex problems, not for whether they write code by hand or run a hundred agents. Anyone who markets themselves as an “AI developer” is one of many. Anyone who solves a specific problem for a specific company can ask for more.

19½ Things You Didn't Know About Accessibility in HTML and CSS

Manuel Matuzović

Manuel came at accessibility from a different angle. He skipped the basics like alt text and contrast and went straight to more advanced topics in modern HTML and CSS. In 19½ tips, he showed how to deal with viewport changes and text zoom, how to use ARIA attributes and roles correctly, and how to work with the Popover API.

We also really enjoyed his look at upcoming features that so far work mainly in Chromium and experimental browsers: the focusgroup and headingoffset attributes, the CSS reading-flow property for Grid, and the Geolocation API. They’re not ready for production yet, but one day they’ll make accessibility a lot easier.

To wrap up, he shared a few tricks for faster accessibility testing, such as Live Expressions in DevTools.

I Will Destroy Your Code and Probably Your Life

Karel Navrátil

Karel walked us through EU regulations. For development, the one that matters most is the SBOM, a list of all your dependencies.

What Kept Coming Up in the Talks

When we put it all together after the conference, a few ideas kept coming up again and again:

• If something can be verified by code, it shouldn’t stay in the prompt only. Jan Kaiser keeps most of his pipeline in plain code, and Petr Glaser turns AGENTS.md into lint rules. The model should interpret the facts, not police them.
• Quality comes from feedback, not from the first prompt. Every fix goes back into the instructions or rules. For Jan, this resulted in a report that hardly anyone corrects anymore.
• “Done” has to be clearly defined and backed up: passing checks, reviews, a screenshot, or a video in the PR. But judging whether it’s really done still takes a human.
• Well-built AI automation doesn’t have to cost much. The log report comes in under $5 a month because the model only gets pre-processed data. What gets expensive is sending the model absolutely everything and using a big model for small tasks.
• Software is made by people, not just code. Developers didn’t save Sazka/Allwyn on their own, and Robin Pokorný talked about the tech lead as a role between people and code. The cheaper code gets, the more decisions, trade-offs, and agreement matter.

Wrapping Up

Code is getting cheaper; decisions and responsibility aren’t. And in our view, that’s exactly where an agency’s value lies: understanding the client’s business, choosing the right trade-offs, and standing behind the result.

What stuck with you most from FrontKon? Let us know, we’d love to talk about it.