Stories

19 Jul, 2026

Prolouge

Back in late 2024, I did a short talk for an internal tech conference titled "Stories".

The idea was to do a non-technical take on where teams can and should go with their software development expertise. In hindsight, I prepared this when I had no exposure to AI-assisted coding agents/output (except the memes LOL) and now, I can't be bothered to check what was considered 'state-of-the-art' back then. I feel like 2024-me had an inkling that it was time to start sharing my technical ideas instead of just keeping to myself/the team, before the wave of AI-generated opinions and code output.

I'm using a re-summarized version of the talk as my first blog entry here, since it indirectly sparked manifesting my ideas over the years into something that's tangible. I'll try to revisit these points now over the next couple of (weekly - planned) entries and see where 2026-me gets challenged. 😬

Set-up

• Kotlin functions that finds min/max from list of numbers

  • One-liners (call min(), max(), stream(), sort())

  • For-loops

  • Functional folds (and to mutable accumulator)

  • Recursion and tail recursion

• Higlights

  • Where the state lies

  • Where the implementation works

  • Where the code cycles (aka 'loops')

    • Tangent: if I were an amateur cyclist instead of recreational, I might standardize to calling agentic loops as cycles and maybe a tangent-off-tangent on cycles-vs-loops...

  • One-liner using standard functions abstracts the state and cycles away, leaving the implementation bare open

  • On the other hand, doing recursion keeps all three visible

  • Different solutions place the state/implementation/cycle differently too (obviously)

TL;DR

Think

• Simple-vs-easy

  • Can a multi-dimensional problem be reasoned through decomposition into smaller, simple one-dimensional ones?

  • Can new requirements be addressed through incremental changes, or is substantial re-work required?

  • Making code easy – fast writes (creation) – may lead to complexity over time – slow reads (consumption)

  • "Duplication is cheaper than the wrong abstraction"; simple in-lined code for reading is cheaper than ease of reusing wrongly abstracted functions, libraries, frameworks

Learn

• What to make explicit; in a nutshell, abstraction

  • Logic layout

  • Data access

  • Program control

  • Language features

• Storytelling

  • What can we learn about the business process, problem-solving steps from the code?

  • What can we learn about you as the developer, the team, and future developers from the code? (emphasis here)

Do

• Code visualization

  • Read more code (emphasis here)

  • Are loops abstracted enough so that the focus is on the solution?

  • Are variables and functions sufficiently encapsulated?

  • Emphasis on faster reads – tending towards simpler code constructs

• Code reviews

  • Yardstick for a team’s technical abilities

  • Programming in a language vs programming into a language

  • Review and refactor the tests

  • Continuous challenging of whether the changes are deliberate, well-intended

• Have your own creative take on programming where applicable!

  • Pet projects; Advent of Code

  • Difference between code generation tasks with generative AI and a desirable level of code quality that is yours to define

  • Enriching one’s code craftsmanship journey (strengths, skills, not necessarily hand-made)

  • Embracing a process that demands time and effort; nimble, agile, but with patience and passion

Read

(basically the hyperlinks)

Epilogue

The 2026 vibe-check: 🪄

• AI agents have obviously made fast writes possible; does it slow down reads for themselves?

• Abstraction is still work-in-progress for humans and AI agents alike

• I feel that when we push code into a 'black box', we will have to start mastering our (human) storytelling... that's a story for another time

• I have written far less code with a keyboard these days, which should not have bearing on reading code... or does it?

• Gotten very good feedback during code reviews, especially when the AI agent runs amok with mechanically fixing one-liner improvements. I really had to shape their behavior (another story-tangent?) in aggregating and responding to feedback

• I still think there's some craftsmanship left, no grief

#abstraction #code review #craftsmanship #stories #storytelling #tldr