Skip to content

From Tool to Way of Working

How a conversation in Berlin, after more than thirty years of software craftsmanship, got me working daily with Claude, ChatGPT and Claude Code – and why I still distrust my own enthusiasm for now.

≈ 10 min readSoftwareAIMethodology

Opening of the series “From Session to System”.

Some time ago, I sat down with Sebastian Korfmann in Berlin. I know Sebastian as a software engineer from the cloud and infrastructure world – someone who doesn’t judge tools by marketing slides, but by whether they take work off his hands in everyday life. He told me about his experiences with AI tools: what he builds with them, how his work has changed, where things get stuck. I listened with interest – and noticed that I had surprisingly little to contribute myself.

I need to explain that. I have been working on software for more than thirty years, a large part of it on distributed systems – Node, TypeScript, GraphQL, cloud architectures – and for many years I gave training for software developers and architects. What appeals to me most about this work: building digital products, and doing it holistically. Really understanding the domain, making decisions about direction, shaping things – for a long time now, it hasn’t been just about programming and architecture for me. Over the years, my focus has shifted too: away from having every fine detail in my own hands, toward structure, consistency, processes, productivity, methods and concepts. Still, I had never worked with AI up to that point. Not a single session, no Copilot. Not out of rejection – fundamental skepticism toward new technology isn’t my style. It simply had never come up. The hype since the launch of ChatGPT at the end of 2022 was impossible to miss – headlines, conference keynotes, colleagues talking about it – but what I heard and read sounded to me like impressive demos, and my days were full. If anything, I was a little reserved – the way you are reserved about things you haven’t tried yourself yet.

There was something else, too, and I don’t like talking about it much, because it has nothing to do with technology and everything to do with me. I had grown tired. Not of the profession, but of a particular kind of undertaking: my own, larger projects, digital products I had carried around in my head for a long time. I know the complexity of such undertakings well enough to know that I can’t deliver many of these topics alone at the quality I expect of myself. The ideas were there, some of them worked out in detail, in notes and half-started repositories. What was missing was the energy for the sheer amount of implementation work – alongside a job and everything else. If you have ever tried to build a complete product on your own, you know the ratio: for every hour in which you really shape something – a decision about direction, a concept, a piece of the domain – there are twenty hours of grunt work. Boilerplate, configuration, forms, error handling, deployment, documentation, plus all the organizational stuff around it. At some point, I stopped opening new drawers, because the old ones were already full.

That was the state I was in when I met Sebastian. What grabbed me about the conversation was the way he told it: no superlatives, no “this changes everything” rhetoric, but the sober way you tell a colleague about a tool that has proven itself in everyday work. I knew that tone, and it made me curious. So I resolved to finally try it out myself. Not for ten minutes, but for a few days, on real tasks.

The first days#

I started with Claude and ChatGPT, in the browser, on tasks from my actual everyday work: reviewing an architecture concept, sketching an API migration, writing a data import I would otherwise have kept putting off. Shortly afterward, Claude Code and Codex joined in – the tools that don’t just answer, but work directly on the repository in the terminal: reading files, changing them, running tests. Anthropic had released Claude Sonnet 4.5 at the end of September, and OpenAI its Codex update at about the same time; without planning it, I got started at a pretty good moment.

And then something happened that I hadn’t expected: within days, I was very taken with it. Not mildly interested – taken. Three things got me:

  • The speed. Tasks for which I would have planned half a day were, within an hour, in a state I could seriously review.
  • The productivity across the whole day. Not a single impressive moment, but the sum: in the evening, measurably more was done than before.
  • The quality. I had expected that least of all. The generated code wasn’t bug-free, but considerably better than I would have expected after everything I had heard and read about generated code – structured, with sensible error handling, often with tests.

The few days of trying turned into weeks of daily work. By now, I work with these tools every day and keep going deeper – Anthropic has just followed up with skills, a way to give Claude reusable working instructions, and I notice that I am starting to read such announcements the way I used to read Node release notes.

A few weeks are not experience. I am aware of that, and that is exactly why I am writing this down. If you become a daily user this quickly, you should distrust your own enthusiasm for now – fresh enthusiasm is a poor witness. So I try to look closely and note down what I actually observe – with the only touchstone I have: more than thirty years of craft against which I can measure every result.

Observation one: generating gets cheap, checking becomes the bottleneck#

I noticed the first shift after just a few days, and it is more fundamental than it sounds. The expensive part of my work was always generating: writing code, wording documents, working out concepts. Checking – reviews, proofreading, acceptance – was the smaller item. That ratio is flipping right now. Generating is suddenly cheap; in one hour, more text and code come into being than I used to manage in a day. What hasn’t gotten cheaper: judging whether what was generated is right. My work is visibly shifting from writing to reading, from producing to assessing.

In a conversation with a colleague, I found a phrase for this that stuck: the tool is less an assistant, more a secretary. An assistant, as the product names promise, adds a line here and suggests a word there – the work stays mine. A secretary in the old sense takes on entire matters: I dictate the intent, they draw up the document, and I sign off. That sounds more convenient, but it is a different responsibility. With an assistant, I check suggestions in passing; with a secretary, I really have to read the finished piece, because my signature is underneath. If you sign without reading, you haven’t delegated, you have capitulated. I suspect that the real overhaul of my way of working lies in this shift – not in the tool itself.

Observation two: the drawers open again#

The second observation is more personal, and it surprised me more than any benchmark. The tiredness I wrote about above isn’t gone – but it has lost its reason. The product ideas that were left lying around because implementing them was too big for one person are suddenly within reach again. Not because the AI builds the product. But because it takes over exactly the part that wore me down: the twenty hours of grunt work around the one hour that really requires thinking. The form scaffolding, the test coverage, the import adapter, the deployment script – all of this now comes into being so fast that, as the saying goes, I can strike while the iron is hot.

Maybe that is also why the whole thing won me over so quickly: over the years, my focus had shifted to exactly where these tools take nothing away anyway – structure, consistency, concepts, the domain, the decisions about direction. The detailed work, on the other hand, and the recurring tasks, including the organizational ones, come more easily to me again now. Not all of them. But enough that it is fun again.

Over the last few weeks, I have been building my own things again in the evenings, voluntarily and with a joy I hadn’t felt for a while. This is where I have to choose my words carefully, because it is so easily inflated into a gospel. So, soberly: for me, AI is above all a lever for the individual with experience right now. The emphasis is on both. The lever works because, after thirty years, I know what I want to build, how it has to be cut and how I can tell that a result is any good. Whether the same lever also works for someone who doesn’t have this judgment yet, I simply don’t know – I have a suspicion, but suspicion is not knowledge, and for this series I want to keep the two cleanly apart.

Observation three: the tone is always right#

I am only noting the third observation briefly, because I don’t understand it well enough yet to make more of it. I notice how these systems answer. In German working life, there is a tongue-in-cheek acronym for it: SABTA – “sicheres Auftreten bei totaler Ahnungslosigkeit”, confident demeanor despite total cluelessness. Psychology knows the pattern as the Dunning-Kruger effect: those who know the least often come across as the most confident. That is exactly how these systems strike me – the right answer and the wrong one come in the same calm, competent tone. In a code review, an unsure colleague gives themselves away through their wording – “I think”, “should actually”. Here, that signal doesn’t exist. Twice in the past few weeks, I almost adopted a claim that turned out, when checked, to be completely made up – an API signature that never existed, delivered with confidence. Both times, only my habit of looking things up saved me. This confident demeanor deserves fundamental distrust, and I want to understand where it comes from – structurally, not anecdotally. I am saving that for later in this series, once I have gathered enough observations.

What this series is meant to be#

I am starting a series here because I suspect the story is bigger than my desk. Right now, I am observing myself: one individual in the session, with direct control over every result. But I don’t work alone – I work in and with teams, and a team is something other than the sum of individual sessions. And above the teams are companies with their processes, their knowledge, their responsibility. I want to walk through this arc step by step in the coming installments: from me through us to the system. Not as theory, but along what I actually experience and try out – including the dead ends, of which there will predictably be a few.

The next question is already pressing. In the team, at lunch among colleagues, most recently in a conference hallway: after a few minutes, the conversation lands in the same place. Which model is the best? Claude or GPT, which version, which benchmark. I have had this discussion myself and developed an unease I am only gradually able to place: after these first weeks of daily work, I notice that the choice of model has changed my results less than pretty much everything else about my way of working. Everyone is talking about the best model – but is that even the right question? I will pursue it in the next installment.

Further reading#

Revised and translated from German with the help of AI.