I started developing RIZM web app November 2021. Back then it was an experiment, after two years we became a funded company backed by Point 9 and Early bird.

As first employee and second full time person in the company I became the lead of app development while others took care of our backend algorithms, infrastructure and database management.

Noticeably I implemented optimistic data saving, migrated our API from Cloud functions to REST API in express.js, added real time collaboration with SSEs and helped migrating our database schema away from EAV model. I witnessed how an experiment became an actual software product which is used by actual people, I still think this is kind of crazy.

During this time I fell in love with vim/neovim, tmux, tiling window managers (thank you aerospace) and note taking (Obsidian). Non violent communication became my most influential book of that period.

I struggle with implementations of "agile" development, although I support it's manifesto. I try to include AI into my dev process and now I find myself switching between Cursor and neovim. Until this day I have problems with finding other likeminded web devs to work with or just to connect to.

My goal with this website is to just say hi and have my own little space in the internet. I learned so much from independent blogs and maybe someday someone will find something that I wrote helpful. Also after implementing a complex SPA at my work it's nice to go back to basics and start with simple HTML.

My journey with agentic coding (so far)

Motivation

Initially, what got me intrigued was a poll in which especially high profile developers reported being really excited about AI. It helped them learn new things faster, deepen their understanding, and approach bigger projects.

In Software Engineering with LLMs in 2025: Reality Check about using coding agents the presenter says if you’re using AI as you did 6 months ago, you’re probably using it wrong. Agents are different.

On the other hand distinguished programmers are also telling us to be careful.

Steve Yegge, the Author of the Book “Vibe Coding” in an interview says: “People expect it to be easy, but it’s not”

He also quotes the software engineer Kent Beck: “Using these agents is like being on a sled going down a ski slope. You’re going really fast, you’re not really in control, you can steer it”

“It is built inherently on a foundation of distrust. You cannot trust anything the LLM gives you”

Martin Fowler: „My former colleague Rebecca Parsons, has been saying for a long time that hallucinations aren’t a bug of LLMs, they are a feature. Indeed they are the feature. All an LLM does is produce hallucinations, it’s just that we find some of them useful.“

So what’s it like to work with such a companion?

General Advice

Steve Yegge again on starting with agents: “And the best advice that I can possibly give you is give them the tiniest task … keep real careful track with them on what they’re working on at all times, and then own every line of code that they ultimately commit”

Simon Willison: - You need to spend time with LLMs and test them in weird ways to get a feeling how to use them effectively - People without prior knowledge might actually have an advantage when approaching AI

So experienced programmers agree that humans still should be checking code for correctness. Or as this blog post puts it: Vibe code is legacy code.

Steve Yegge: “Everyone will need to get a lot more serious about testing and reviewing code.”

In Writing Code Was Never The Bottleneck the author argues that checking, understanding and correcting AI(s) will be increasingly important but is also something that cannot be scaled as easily as writing code.

Unsupervised, unconstrained AI will lead to failure, so it’s important to mitigate these issues. This post had some tips I found quite helpful.

Design for failure: Have a reliable rollback mechanism for when things go wrong.

Define clear boundaries: Limit scope and permissions of what an agent is allowed to do on your computer. Otherwise it’s easy to land in the The lethal trifecta for AI agents.

General Experience

Probably the best summary of how I experienced working with AI comes from Dreams of Code and I highly recommend watching it if you’ve never worked with AI agents.

People have found different ways of describing what working with an agent feels like. Kent Beck calls it a genie, like a thing that grants all your wishes. Only, it also likes to trick you if you’re not specific in your wording.

Andrew Karpathy calls them people spirits, stochastic simulations of people. It captures that feeling of communicating with something human-like until it loses touch with reality and starts hallucinating.

Also many people compare it to managing junior developers that are super fast, highly motivated and a little overconfident. Only AI does not learn from its mistakes because of its small context window.

You can compensate a little with providing it with a file like CLAUDE.md that the agent always reads into its context. But even with that I could for example never get it to reliably fix linting errors after coding.

Tools and setup

I tried Cursor for a couple of weeks but it disrupted my workflow too much for me to ever get comfortable with it.

Claude Code fit my setup perfectly since it’s running in the terminal it’s easy to include it with my neovim/tmux setup.

What Boris Cherny and Adam Wolff from Anthropic say: Making Claude Code tool agnostic comes from the uncertainty what the best workflow with AI is so they make it as general purpose as possible. Claude Code does not force a specific workflow on the developer, it gives you the freedom to decide how you want to use it.

The only thing currently missing in my neovim setup is an LLM-based autocomplete but this seems to be in the making

Git Worktrees are insanely useful even without AI. Every worktree is a separate clone of your repository which enables you to have multiple branches checked out at the same time. With LLMs that means having multiple agents working on separate tasks in parallel.

This post gives a great introduction and why to use them. A quick way how to set them up in a clean way can be found here. It also has good further references if you want to dive deeper into that topic. This post describes how using scripts can improve using git worktrees.

Workflow

Currently, what’s working best for me is what Anthropic describe as Explore, plan, code, commit:

In planning mode I give the AI all the relevant context and give instructions as specific as I can. This is what’s called Context Engineering and it’s an art and a science.
I review the AI’s plan and iterate on it until I feel like it’s good enough.
I let it write the code. As recommended in Coding agents I do not confirm edits.
In the end, there is often still some work left that is done quicker manually. I liked what Zach Loyd from Warp said: “All of our features start with a prompt, not all of them end with one.”
(Optional) One nice trick I found is letting it write a summary or the current state of a project into a corresponding ticket. In my case it was as easy as connecting Claude Code via MCP to our ticketing system linear. It’s nice for documentation purposes and also functions like a CLAUDE.md that I can point the AI to. If you’re not working with a ticket system it can also just be a text file on your computer.

One thing I’d like to try in the future is Test Driven Development (TDD) which for me has become a lot more viable with AI agents. For now I’m still working on improving our existing tests.

Challenges

For me personally one major challenge is how to use AI responsibly in a way that does not atrophy your skills. It can be tempting to just let AI do everything. Rather try to use AI to deepen your understanding of a topic or to learn new things faster. Don’t let AI make you worse.

Also letting AI write your code might rob you of flow or feelings of achievement. On the other hand for many it also sparked new motivation for just starting new things.

On an organizational level I liked this quote from Yegge: “…and you can get a gazillion PRs through if your organization is willing to speed up the bottlenecks. And some organizations are and some organizations aren’t willing to let that speed up, and you’re going to start seeing them separate very quickly. And of the ones who decide to do it, you’ll see some of them turn into trainwrecks, they become very public potentially, and then you’ll see some of them succeed”

Summary

After almost three months of using AI agents, I barely write any code myself anymore.

Even though AI sometimes fails it’s just so easy to try again with a better prompt, another iteration in planning mode or splitting a task into smaller chunks.

One thing that did not work for me was integrating an auth emulator suite into my app even though I pointed it to its documentation. Luckily in the end it was only a handful of code I could write by myself.

To me they were especially helpful with starting bigger tasks, writing and maintaining tests, approaching big refactorings, helping me with SQL queries or writing documentation. Chores in general become much more bearable so you can concentrate more on implementing cool stuff. Agents also let you iterate over code and ideas much faster and by that accelerate getting you to a good approach for any given task.

And although I wrote this blog post myself, AI helped a lot in refining its structure or fixing my typos.

Currently, there is still a lot of hype going on regarding AI. Maybe the launch of GPT-5 marks a turning point in this regard. Some say it’s currently the best existing model but in comparison to earlier releases it seems to only marginally improve over older models. This leads me to think that at least for the foreseeable future good engineers are still needed.

So in summary I think AI is a great productivity tool although it might not instantly turn me into a 10x developer.

Hi there, I'm Niklas

Welcome to my corner of the internet