Software Development with AI
Software engineeringSix essays on what AI actually does to the practice of building software: writing code is no longer the bottleneck — the work moved to communicating intent upstream and verifying output downstream.
I am an agile and pragmatic software engineer and technology consultant with a passion for driving innovation and excellence.
My role often transcends traditional boundaries, embodying the essence of an enabling team consultant, tech lead, architect, full stack developer, and QA.
Software engineering is a multifaceted discipline that has to integrate technology, social team dynamics, and business strategy. This makes software engineering a complex domain and many decisions are tradeoffs.
The only constant is change. Coding agents have moved the bottleneck from writing code to specifying intent and verifying results — and as review itself becomes automatable wherever the code is simple and well-tested, the constraint settles back onto intent. The work shifts from conductor to orchestrator: from pairing in dialogue to dispatching tasks that run autonomously for hours.
At the core of software engineering lies a robust set of technical practices encompassing programming, testing, debugging, and architectural design.
Working with coding agents does not remove the need for discipline — it relocates it. Rigor moves out of the code itself into the specifications, tests, and scaffolding that surround the agents. The mode shifts from conductor to orchestrator: from pairing in dialogue to dispatching tasks that run autonomously for hours — a double diamond (discover, define, develop, deliver) verified by AI agents, trustworthy only when the specs, the harness, and the QA gates are good enough.
The longer treatment lives in two standalone sites: Software Development with AI, six essays on how the work moved from writing code to communicating intent and verifying output, and Lights On, Lights Off, a textbook on AI software factories — "lit" ones keep a human reading the diff, "dark" ones let machines verify machines.
The success of software projects often hinges on the dynamics within development teams. Agile methodologies promote iterative cycles of planning, prioritization, and execution, fostering a collaborative environment where communication and fast feedback is key.
A strong DevOps culture, which blends development and operational activities, enhances the efficiency and reliability of software by fostering closer collaboration and integration between teams.
A decentralized approach to architectural decision-making is important, to empower teams to make choices based on their specific contexts and challenges.
The strategic aspect of software engineering involves aligning projects with the organization's broader goals and objectives. The overarching aim is to ensure that software engineering efforts support the organization's direction and add value.
Standalone websites built with AI, one software engineering topic per site:
Six essays on what AI actually does to the practice of building software: writing code is no longer the bottleneck — the work moved to communicating intent upstream and verifying output downstream.
A ten-year timeline (2026–2036) for software development and consulting, priced on one thesis: the artifact got cheap, the accountability didn’t. A claims audit and a nine-metric dashboard state in advance what would force a re-price.
A textbook on AI software factories: “lit” ones keep a human reading the diff, “dark” ones let machines verify machines. Its advice is to earn the dark with evidence, one narrow loop at a time.
An eight-module introduction to Domain-Driven Design — Ubiquitous Language, strategic design, tactical building blocks — taught through a single running order-fulfillment example.
A hands-on, eight-module course teaching Java and JVM developers to pair effectively with Claude Code — from first session to team-wide adoption, with Maven, Gradle, Spring, and JUnit examples throughout.
A curated tour of my public repositories on github.com/jdinkla.
A personal Claude Code plugin marketplace — a catalog of plugins (skills, slash commands, agents, hooks) installable with one command.
Slash commands for high-level software engineering: architecture, Domain-Driven Design, Architecture Decision Records, and quality & maintenance work.
Skills and slash commands for user story refinement across the full lifecycle, from discovery through post-release — INVEST reviews, acceptance criteria, splitting, and more.
Turns a source essay into visual media — slide decks and single-page infographics — with multi-provider text and image generation.
Multi-provider AI image generation library with a unified client API across Gemini, OpenAI, and xAI. Published on PyPI.
Structural analysis tools that extract a codebase's architecture, compute coupling metrics, detect cycles, and render reports and diagrams — one tool per ecosystem.
Static analysis for Kotlin codebases: dependency structure, coupling metrics, and architectural visualizations.
The same analysis for Java programs, implemented in Kotlin.
Structural analysis for TypeScript and React codebases — afferent and efferent coupling, circular-dependency detection via Tarjan's SCC, Mermaid diagrams, and a self-contained HTML report.
Browser-based, built with AI coding agents.
A management simulation that teaches the verification paradox: higher AI adoption generates more code while review capacity stays fixed — without investing in verification, delivery slows down.
A Scrabble-like single-page game against an AI opponent with three difficulty levels — full rules, cross-word validation, bingo bonus.
Guess-the-city quiz: a red dot on a continent map, multiple-choice answers. Built with React and Leaflet.
A vibe-coded game for learning the flags of the world's countries.
Maze generation and solving algorithms from Jamis Buck's "Mazes for Programmers", with a solver arena where pathfinding algorithms race through generated mazes.
A Rust port of Jamis Buck's "The Ray Tracer Challenge", verified by the book's own Cucumber/Gherkin specs — 313 scenarios.
The same book implemented in Kotlin.
A ray tracer inspired by Kevin Suffern's "Ray Tracing from the Ground Up".
Nearest-neighbour search with k-d trees on Apache Spark.
A library of geometric algorithms and data structures for Haskell — convex hulls, triangulations, Voronoi diagrams — written in 1998 for my diploma thesis, and still building on a current GHC.
Examples for the OpenAI API and LangChain.
Round-trip experiment: GPT describes an image, then an image model regenerates it from that description.
A small RSS reader for InfoQ news, built to try out Google's gemini-cli.
Example code for my JavaSpektrum article on Structured Concurrency — the JDK 24, 25, and 26 preview APIs kept side by side so the differences are easy to see.
Documents and code from the "Coding da Vinci Nord" 2016 culture hackathon, analyzing a family-names dataset.
Older talk and article code, kept read-only: Kotlin coroutines (parallel 2019) · structured concurrency warm-up (KKON 2021) · KKON 2022 talk · cuDNN example from iX Developer 2018 · GPU computing (parallel 2017) · parallel 2015 · parallel 2014 · parallel 2012 · email analysis with Spring Boot & Elasticsearch · disk-usage pie charts in Groovy · Eclipse Modeling Framework with Groovy · Common Warehouse Metamodel in EMF · family-name graphs via Levenshtein distance · Markov chains for Ruby Quiz 74 (2006).
Lean Thinking is more than just a set of management tools; it is a philosophy centered on maximizing customer value while relentlessly eliminating waste. At its core, it challenges us...
The Thoughtworks Technology Radar has always been more than a list of tools. It captures what happens when technology moves from experimentation to everyday practice. In its 33rd edition, one...
I’m excited to share the first MVP release of NKP (aNalysis of Kotlin Programs), a command-line tool for analyzing Kotlin codebases and uncovering architectural insights.
I’ve written a new article for JavaSpektrum: “Java im Technology Radar – Totgesagte leben länger”. The piece looks back at Java’s journey through the eyes of the Thoughtworks Technology Radar...
I’ve written an article for JavaSpektrum 2/2025 about Structured Concurrency in Java 24. The article covers JEP 499, Java’s fourth preview of Structured Concurrency, which aims to make concurrent programming...
As an external consultant in an Enabling Team for Cloud Architecture, I supported several teams and noticed that software development quality was lacking. This surprised me because the client was...
Concurrent and asynchronous applications can be written in Kotlin with coroutines in a precise and structured way. Unfortunately, concurrency often increases the complexity and it is difficult to create bug-free...
In my talk “Nebenläufigkeit mit Koroutinen strukturieren” at the KKon 2021 Warmup I explained how to structure and organize concurrent programs with coroutines in Kotlin.
During the chrismas holiday I started a new ray tracer in Kotlin while following the book “The Ray Tracer Challenge.
I updated my website so that it looks new and shiny and provides faster and easier access.