My Writing and GenAI

I follow my plan of focusing on fewer tasks. This puts a lot of pressure on my time. In addition I spent almost every evening of the last months exploring GenAI. My wife got sick of me talking about agents, tokens and the like. Besides my feelings about the change of our industry I did not write much. Having little time and less practise in writing made writing more unlikely - a vicious cycle. I had no idea where putting my thoughts would end up. It might become a rant. (Sidebar 1)

Working With Text
What to look for? I use writing to structure my thoughts. This is rubber ducking, a practise of talking through a problem. In doing so, your brain structures the problem as part of communication. This often lets us find the solution to the problem. I learnt about this technique from The Pragmatic Programmers, a book I recommend since 2011. The idea itself is way older and based on Joseph Weizenbaum's ELIZA from 1966. (You can try ELIZA here.)

More than once the outcome of my writing was different than I had expected or planned. I partitioned and analysed the problem during writing and found better results. This is the benefit. I lose if AI writes the text for me. It will format my notes nicely and present something that looks reasonable but it will not end with opposing results. And even if it would, I would reject them because I am unprepared for opposing results. I need to go through the work of structure and analysis to find and accept a different outcome than I had anticipated. My writing needs to be slow and meandering and cumbersome.

When writing about technical topics, e.g. the latest Coding Fun, I have to structure the material linearly to make it possible to read for people who are unfamiliar with what I want to present. This makes me reflect on the topic from a distance, after I had been in the fine details all the time. This summary adds to my understanding of the material.

On LinkedIn is a group of people who claim that they put as much thought and effort into their AI generated articles - which would also mean they get the same benefits. I do not know, maybe they do. But Mathias Verraes disagrees. He claims to recognise AI-generated text because he read so much. The generated text contains the same cliches and seems to be uniform - for sure statistically averaged. These articles are boring which makes them unreadable. (Sidebar 2)

I do not write enough and miss practice. Getting started is difficult, collecting ideas takes time and I edit everything more than once. I guess Mathias will resent my writing. ;-) I struggle with articulation as English is not my first language. I could use GenAI to improve my articulation - it would keep my ideas and thoughts, at least according to the proponents of GenAI. But I reject it. I want to improve my articulation myself. Articulation is a skill, writing is a skill, and both need practise. (Sidebar 3)

I like writing by hand, or should I call it writing manually: I am creating something and showing the world. Using GenAI for my writing removes all these benefits: I am not structuring, expressing, and polishing my thoughts. I am not summarising known material. And I am not practising and improving my writing. Dylan Beattie phrased it in his GeeCON 2026 keynote: "If something is fun and you're learning - using AI brakes both."

What Makes A Person?
Another goal of my writing is to share my knowledge. Other than expressing myself, sharing is a marketing tool, at least part of developer branding. As GenAI disturbs my beloved coding, I need to rethink my business. What makes me successful since 15 years? Besides my technical expertise I believe I am successful because I am authentic. I teach what I know and have experience from past projects and always state up front when I have no clue. (Sidebar 4) I avoid marketing buzz words and stay away from promising anything. I demand perfection from others and even more from myself. I live what I preach. I have no idea what my clients buy when they hire me for the first time (when they do not know me yet). I believe they buy the promise of my reputation. All my work comes through personal recommendations. (Thank you so much my friends.) For sure a large part of my business depends on my contacts and personal, authentic connections. Being honest, admitting mistakes and taking responsibility for my actions are important to me. No generated text, regardless how well structured and nicely sounding, supports those.

Generated Correspondence
In the early days of Chat-GPT I ran an inhouse Coderetreat for one of my clients. A local organiser sent an invitation to all developers. Instead of writing one or two sentences about the upcoming event, he generated a full page of text about being "delighted" to host such a "spectacular" event and more exaggerated terms. This is a common problem. Me friend Raimo writes about interacting with coworkers talking to us only through parrots which makes him frustrated or angry at times. I fail to understand why people would do that. (Sidebar 5) Particular in an corporate environment, nobody cares for style or typos in work emails. As time is money, long emails and chat messages are discouraged. The respect for our coworkers' time should stop us from creating (large amounts of) useless text. Please never send me AI generated text. I will never use AI for mails or personal messages.

I am a geek, spending my evenings alone, in a dark room filled with hardware and pizza boxes - at least kind of. And at the same time I like working with people. I value human connection. It makes much of my work meaningful and worthwhile. Human beings are social, everybody needs human connection somehow. To connect I need to express my feelings (like about accepting GenAI) and I want to be seen. AI is unable to express my feelings and it certainly can not make me seen. Connection is not happening if I do not expose myself.

My AI Writing Manifesto
After collecting notes and thoughts since May this year, structuring my thoughts and polishing then, I found clarity:

• I structure and formulate my thoughts and ideas myself. AI does not support me in digesting and distilling content.
• I summarise technical expertise myself. AI does not support me in finding deeper relations based on known material.
• I author and polish my writing myself. AI does not support me in practising and improving my writing skill.
• I keep a honest and authentic relation to my clients and peers. AI is neither.
• I respect your time and keep all messages short. AI generates bloat.
• I write all messages myself to express my feelings and to be seen. AI hides me.
• All images I use are real images, unless marked as AI generated.

---

Footer
I was massively distracted while writing. I kept finding notes from the last five months on different aspects of this. The topic had been on my mind for some time. After finishing the outline I streamlined the text and moved my secondary thoughts into this section. While off-topic these thoughts were reasonable - I might expand on them later.

Blog Rants: I have not written any rant since I went independent. This is a good thing. I do not miss the corporate politics and hidden agendas.

Hate of Generated Text: In my social "bubble", there is a crusade against AI generated text. I can relate. The massive creation of AI slop is speeding up the Enshittification of the Internet. For example: This January I suffered from pneumonia. Staying in bed I searched the web for articles comparing AC generators. I planned to buy one powering tools in the garden. The web search showed promising results. But each page turned out to contain generated text of products with deep links into Amazon, and no real descriptions nor any comparison. Maybe due my weakened state, I was devastated. I recognised that the Internet was broken. That was not the web I had learnt to trust for its usefulness.

Practice and Mastery: I am a big fan of deliberate practise. I practice deliberately since many years and have talked about it in the past. I use that approach for all areas which I care for and where I want to improve. I want to achieve mastery (as a path not a state). Maybe this is folly: I am in a position of privilege which allows me to reflect on my skills and put aside time to practise, which is like play, unproductive. I am able to laugh about failed attempts and try again. I like the experience of the flow you get after reaching a certain level of skill. Having invested huge amounts of time into practise makes me respect the effort and skills of other people. Coming back to AI writing - I am unable to respect neither the author nor the work using AI because there is little effort and skill required.

Working with technologies I do not know is an interesting situation as a coach. I always confess in the first meeting with the client when I have no experience with certain technologies they are using. 12 years ago, I worked with a company using PHP. Back then, they used PHP 5, which had a bad reputation. I had never seen any PHP before. I struggled a lot with its dereference operator -> and always used the more common . instead. When pair programming I always mistyped it and one of my pairing partners designed a T-shirt for me saying "this -> is not this .". In the end I knew more about PHP than most developers I paired with because I knew what to expect from a language and how to google it. Another time I worked with C# which I had never touched before. That was even easier, as at the time, C# was "Java in Pascal case". ;-) After learning some programming languages, at least the main stream ones, all languages look the same.

Why generate bloated text? I am wondering which universal human need is met when people generate work emails with GenAI, making them many times larger than necessary. It is not efficiency, as the prompt takes longer than the pure message. It is not reputation, as everybody recognises the generated text. (Ha ha sequences of "it is not" are a sign of AI generated text. Fear not dear reader, I am able to author bad writing without any AI any day. ;-) People generate content for Wikipedia - which is vandalism and go on when asked about it. Which need is met by these actions? I will have to investigate. The best I know is "because I can" which is self-efficacy, an important need indeed.

Accepting GenAI

My Blacklist of Technologies
When I started out as a Java developer, I wanted to know everything about Java. I wanted to know all libraries and all frameworks. What a silly idea. Clearly Java or software development in general was and still is way too vast to know everything. Beginning 2003, I started ignoring certain technologies. I maintained a black list of topics and libraries, e.g. I decided to ignore all Java web frameworks. Later I ignored EJBs and then I added the whole Spring ecosystem to this list. While I knew these things existed and I had a working knowledge for my day job, I would refuse to study them in my personal free time. There was nothing wrong with these technologies. I did not find them interesting. Using that approach, I successfully skipped all the rage about SOA and other hypes, and I am not looking back. ;-) Explicitly ignoring topics helped me to focus on the things which I liked and considered important.

Scary or Awesome or What
And then ChatGPT came out. (The Wikipedia link is probably unnecessary.) There was an extreme buzz around it, and because of that I wanted to ignore it. A few months later I worked with a group of interns at one of my clients. These young people were enthusiastic about AI - most of them paid for pro versions from their own money - and they encouraged me to look into it. And so I did. And I got frightened. I enjoyed every post that diminished LLMs as stochastic parrots. Let's face it, isn't it weird when a machine can have a conversation with you? I am full of awe, also in a scared way - I am unsure what the right word is to describe my feeling.

Since last year, all of my clients ask for workshops to improve their coding with the use of AI. Code assistants and agents - augmented coding - get better and better. And sometimes the results are surprising. In the end, it is the same if AI works for coding or not - the industry has already decided on its adoption. For some time, I tried to deny it. But after Dave Farley's study about developers using AI, there was more denying it. I had to accept that AI will take over coding. (Dave Farley's video is 12 minutes, without hype, and in the end he gives a clear direction to follow. You should watch it.)

Fear of Obsolescence
Software development is changing quickly, and many of our skills become worthless (says Kent Beck). I read somewhere that "every technological revolution has displaced skills that people spent years mastering" and that "the people that are really skilled, have a lot of room to fall." (says Bryan Seegmiller). Yes, I feel like that. Coding is more than my work (and my fun), it is my identity. I have been playing with code since more than 40 years now. During this time, I have even established habits to use coding for relaxation, and I like exploring topics around code. I do not mean development, I particularly mean coding. I am the Code Cop and I am obsessed with manipulating the textual structure, improving its readability, exploring symmetries, tweaking it, moving it around like clay, and so on. And now all this is going away and it is scaring the hell out of me.

How am I dealing with all of this?
A senior developer from one of my clients, struggling with AI adoption himself, asked me how I am dealing with all of this? I am not, or at least not well. I thought about moving into areas where AI is useless and uncommon (yet?). For example, a study showed that AI is less effective on COBOL and other legacy code. Lovely! I bought a bunch of COBOL courses, and planned to take them. I had several other ideas, too, none of them really helped me till now. The core goal of this post was to list a few resources which really helped me:

• Maybe the first step is accepting the use of GenAI.
  
  
• I highly recommend this podcast with Grady Booch about the third golden age of software engineering. Grady Booch's approach is historical and more systemic. He is calm, with good perspective. It is 80 minutes long, audio-only is enough. This is the first piece that helped me to a more positive attitude.
  
  
• Kent Beck, who probably lost more to the rise of augmented coding than anybody, is lovely. In his conversation with Trisha Gee about Skills Developers Need to Have in an AI Future, they talk about developers losing confidence that they will be able to learn the next set of necessary skills. How true.
  
  
• Embrace Change is the second principle of the Agile Manifesto. While I try to stay clear of processes and am okay whether we use waterfall or Scrum or whatever, I do care about the code, and I favour Embracing Change there, designing in a way that would allow changes. Keeping software soft. Recently I was reminded of that fact by a fellow technical coach. So let's embrace change, even if it is frightening right now.
  
  
• Last month Kent Beck started a new podcast Still Burning where he has honest conversation about what it actually feels like to work in this moment - the fear, the uncertainty, the quiet disorientation of tools changing faster than understanding can follow.. The acknowledgement of these feelings, the disorientation, this is balm for my soul. I have always admired Kent Beck and the podcast setup is so grounded (actual fire, real smoke, Kent is coughing) and humble, it is already a classic.

What Next
These discussions helped me, and I hope they will help you, too. Am I done? I stay critical of using AI, its effects on me, my skills and the world in general. At the same time I try to board the AI train and follow along with the current. There are plenty opportunities to participate in AI experiments right now. Hopefully that will be enough to stay on the topic. My fear of missing out is real, I spend too much time with Generative AI. My wife already urges me to take a break from all this. It is exhausting. Everywhere it is just "AI", "AI", "AI".

Von Neumann Turing Machine

On my search for harder coding challenges, join me implementing Fizz Buzz using a Turing machine where I dive into Turing machines from a practical coding perspective using Java. In the previous part I finally understood Turing machines (TM) and created a Universal Turing Machine (UTM) using a Tape and TuringMachine classes. This is the second part.

Fizz Buzz
I want to implement Fizz Buzz but I have no idea how to start. A simple implementation in Java might be:

for (i = 1; i <= 100; i++) { // line 1
  if (i % 3*5 == 0)
    print("FizzBuzz");
  else if (i % 3 == 0)
    print("Fizz");
  else if (i % 5 == 0)
    print("Buzz");
  else
    print(i);
}

Fizz Buzz is an easy problem, still it needs several programming constructs: Looping or sequences, conditional logic, arithmetic with integers including division for the remainder, strings and some form of input and output. The input is the number of lines required, in the code above hardcoded to 100, and the display showing the result, e.g.

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

What is the end state when I miss a display? For a TM the input will be the number on the tape and the output will be the list of strings on the tape again.

Representing Numbers
I am overwhelmed. When working katas, exercises or new languages, I usually create the code bottom up, making things up on my way. Following that approach, I have to figure out individual operations first, then will I combine them into more powerful programs. For Fizz Buzz I first need to count from one to 100, incrementing by one. The smallest (binary) space to represent the number 100 needs seven bits which are seven cells on the tape containing a '0' or '1' followed by a separator '$', e.g. 100 would be 1100100$ on the tape. (To make my life easier, I assume the set of symbols contains arbitrary characters. After all each character is a sequence on bits anyway.) The separator helps because it avoids keeping track of positions inside the sequence of working with bits during some operations. (This is one of many design options. Another approach would be to store the position of each bit next to the bit on the tape.)

Incrementing Numbers
The first operation I need is INC (increment by 1). Increment, an x86 assembly op-code, adds 1 to an unsigned integer operand. (Now - when writing this - I see why I ended up where I ended up. My first idea for a building block was a CPU assembly operation on a sequence of bits. From there I was following the given direction...) If you never did any assembly, let me explain INC operating on a binary numbers. Let's assume a value, e.g. 78, binary 1001110. The increment adds 1,

01001110
+      1
--------
 1001111

Like adding regular (Arabic base 10) numbers, addition starts most left. The 1 adds to the 0 and we are done. In short, if there is a '0' bit, it becomes a '1' and that's it. So 78 becomes 79. Let's increment it again:

01001111
+      1
--------
 1001110
+     1  ... overflow from the first digit
--------
 1001100
+    1   ... overflow from the second digit and so on
--------
 1010000

which is 80. In short, if there is a '1' bit, it becomes a '0' and INC continues incrementing left with the overflow.

INC on the UTM
Working on the tape of the TM, the algorithm to increment the number right of the read/write head is:

1. Move the read/write head right until the end of the number (i.e. until the '$') to do the increment.
2. Work backwards, i.e. move left to increment.
3. If there is a '0', then write a '1' which finishes increment - and start moving right to the end.
4. If there is a '1', then write a '0' and continue incrementing left with the overflow bit.
5. In the end move right until the '$' to leave the read/write head in a consistent state.

The last bit must not overflow. Increment's transition table is

Step	state	symbol	newState	newSymbol	direction
(1)	Inc	any	Inc_MoveRightAndInc	same	R
	Inc_MoveRightAndInc	'0'	Inc_MoveRightAndInc	same	R
	Inc_MoveRightAndInc	'1'	Inc_MoveRightAndInc	same	R
(2)	Inc_MoveRightAndInc	'$'	Inc_IncToTheLeft	same	L
(3)	Inc_IncToTheLeft	'0'	Inc_DoneMoveRight	'1'	none
(4)	Inc_IncToTheLeft	'1'	Inc_IncToTheLeft	'0'	L
(5)	Inc_DoneMoveRight	'0'	Inc_DoneMoveRight	same	R
	Inc_DoneMoveRight	'1'	Inc_DoneMoveRight	same	R
(T)	Inc_DoneMoveRight	'$'	Halt	same	none

This table is a standalone test program a.k.a. a Turing machine. Line (T) stops after incrementing a given number. I can unit test the code comparing tapes, e.g.

@Test
void incZero() {
  transitions.addIncTo(table);
  createMachineWith("0000000$", Q.Inc, table);
  machine.loop();
  assertTapeEquals("0000001$");
}

@Test
void incOne() {
  transitions.addIncTo(table);
  createMachineWith("0000001$", Q.Inc, table);
  machine.loop();
  assertTapeEquals("0000010$");
}

@Test
void incToMax() {
  transitions.addIncTo(table);
  createMachineWith("0111111$", Q.Inc, table);
  machine.loop();
  assertTapeEquals("1000000$");
}

DEC (Decrement by 1) is the same with '0' and '1' switched. Now I know how to build individual operations.

More Operations
Next operation is DUP (duplicate a number). Things get cumbersome because the state of the current bit, i.e. if DUP is copying '0', '1' or '$' eight places to the right has to be encoded in the states. For example the transition table to duplicate a '0' is

state	symbol	newState	newSymbol	direction
Dup	'0'	Dup_Move7RightAndWrite0	same	R
Dup_Move7RightAndWrite0	any	Dup_Move6RightAndWrite0	same	R
Dup_Move6RightAndWrite0	any	Dup_Move5RightAndWrite0	same	R
Dup_Move5RightAndWrite0	any	Dup_Move4RightAndWrite0	same	R
Dup_Move4RightAndWrite0	any	Dup_Move3RightAndWrite0	same	R
Dup_Move3RightAndWrite0	any	Dup_Move2RightAndWrite0	same	R
Dup_Move2RightAndWrite0	any	Dup_Move1RightAndWrite0	same	R
Dup_Move1RightAndWrite0	any	Dup_Write0AndMove7Back	same	R
Dup_Write0AndMove7Back	any	Dup_Move7LeftAndStartAgain	'0'	none

There are 9 state transitions for each "bit" - to "remember" the bit - and additional 7 states to move left again and start over, giving a total of 34 states for my simplified transition table allowing shortcuts for any symbol etc.

I am still implementing line 1 in the code on top of the page:,Counting from one to 100, incrementing by one. To create a loop, I need to start with one (0000001$), duplicate it, increment the new number, and repeat while it is less than 100 or until it is 100. The instructions LESS and EQUAL are similar to DUP. The current symbol has to be "remembered" in the states, the tape has to move eight places right and the comparison with the symbol there determines the result of the operation, then the tape has to move seven places left again and restart the operation.

Combining Operations
I started with x86 operations and I follow the idea further. I dislike duplicating INC or other states so I create a lookup table - an area on the tape that would be holding the program, think Code segment from x86 architecture before x86-64. The read/write head will have to move between the code and the data (think Data segment) and I need markers for both positions. Let 'P' be the Instruction Pointer (usually called IP) and 'C' be a cursor marking the last position the read/write head had when working with data. Each operation will

1. Move the instruction pointer to the next instruction by switching the letter of the operation with 'P'.
2. Move the read/write head right to the cursor 'C'. There replace the cursor with the separator '$'.
3. Perform the operation. Each operation must end with the read/write head positioned at a separator.
4. Set the new cursor position.
5. Move the read/write head back to the instruction pointer
6. and start over.

Storing the program and the data in the same place, i.e. the tape, makes this a Von Neumann architecture. When the UTM is processing instructions in the left side of the tape, it cannot work with data, which is on the right side of the data and vice versa. The term "von Neumann architecture" refers to any stored-program computer in which an instruction fetch and a data operation cannot occur at the same time (since they share a common bus) says Wikipedia.

INC as Instruction
Increment's extended, full transition table is

Step	state	symbol	newState	newSymbol	direction
(1)	Ip_SwitchRight	'i'	Ip_SwitchLeftInc	'P'	L
	Ip_SwitchLeftInc	'P'	Code_Inc	'i'	none
(2)	Code_Inc	'C'	Inc	'$'	R
	Code_Inc	any	same	same	R
(3)	Inc	any	Inc_MoveRightAndInc	same	R
	Inc_MoveRightAndInc	'0'	Inc_MoveRightAndInc	same	R
	Inc_MoveRightAndInc	'1'	Inc_MoveRightAndInc	same	R
	Inc_MoveRightAndInc	'$'	Inc_IncToTheLeft	same	L
	Inc_IncToTheLeft	'0'	DoneMoveRight	'1'	none
	Inc_IncToTheLeft	'1'	Inc_IncToTheLeft	'0'	L
	DoneMoveRight	'0'	DoneMoveRight	same	R
	DoneMoveRight	'1'	DoneMoveRight	same	R
(4)	DoneMoveRight	'$'	Ip_Restart	'C'	none
(6)	Ip_Restart	'P'	Ip_SwitchRight	same	R
(5)	Ip_Restart	any	same	same	L

and its test

@Test
void inc() {
  createMachineWith("PihC0000000$", Q.Ip_Restart, transitions.create());
  machine.loop();
  assertTapeEquals("ihP$0000001C");
}

Letters 'i' and 'h' represent operations INC and HALT. After execution the instruction pointer moved two places to the right and the data cursor moved one number entry to the right.

Other Instructions
The extension of the partial transition tables of DUP, LESS, EQUAL and operations to move the cursor left and right as instructions 'd', '<', '=', 'l' and 'r' is the same. States DoneMoveRight and Ip_Restart are generic and used by most of these instructions. See the full transition table here.

This concludes the second part of my Turing Machine exploration. I spent too much time formatting transition tables. Now I have a machine on top of a machine. I made the problem easier by adding another level of indirection, an application of the Fundamental theorem of software engineering. ;-) Stay tuned for part three.