The Main Thread started with Java and Quarkus, and those are still a big part of it. But the publication has grown.
Today I write about Java, Quarkus, agentic engineering, AI-assisted software development, architecture, developer tooling, and the changes happening to the way we build software.
This page answers the practical questions about what I publish, who it is for, how AI fits into the process, and how you can use the code and ideas.
What is The Main Thread?
The Main Thread is my independent technical publication about software development.
Most articles start with something I want to understand myself: a framework feature, an architecture problem, a new tool, a production failure mode, or a change in how we build software.
I usually build something around it, test the boundaries, and then write about what I found.
Some articles are hands-on tutorials. Some are experiments. Others are architecture or thought-leadership pieces where the code matters less than the engineering decision behind it.
Who is it for?
The primary audience is experienced developers, architects, and platform engineers.
You do not need to know every technology I write about. I try to explain enough context that a Java developer can follow an article about agents, and someone exploring Quarkus can understand why a particular architecture decision matters.
But this is generally not beginner programming content. I assume you know what an API is, have deployed software before, and understand that production systems behave differently from tutorial examples.
There are beginner-friendly articles when a topic needs them. They are starting points, not the main focus of the publication.
What topics do you cover?
A few threads show up again and again.
Java and Quarkus are still the technical foundation. That includes framework behavior, APIs, testing, security, performance, observability, build tooling, and production architecture.
Agentic engineering covers coding agents, MCP, ACP, memory, tools, permissions, workflows, evaluation, hooks, guardrails, and the engineering around systems that can take actions.
AI-assisted software development looks at what transformer models change about coding itself: specifications, reviews, debugging, architecture, maintainability, and developer responsibility.
Software architecture connects all of this. I keep coming back to boundaries, contracts, failure modes, long-lived systems, and the cost of decisions that look simple today.
And occasionally I find something interesting that does not fit neatly into any of those buckets. I usually write about that too.
Are the tutorials hands-on?
Yes.
For hands-on articles, I try to give you enough to actually reproduce the result. That usually means pinned versions, project setup, complete code, configuration, verification steps, and an explanation of what breaks outside the happy path.
I care especially about the last part.
Getting an endpoint to return 200 OK is the beginning. I also want to know what happens under load, what the security boundary looks like, where concurrency becomes a problem, and what the implementation does not guarantee.
Most hands-on articles have companion code on my GitHub account.
How much of The Main Thread is created with AI?
A lot.
The Main Thread is heavily AI-assisted.
I use transformer models for research, exploration, coding, reviewing assumptions, comparing approaches, structuring articles, editing drafts, and sometimes finding a completely different direction from the one I started with.
There is no useful percentage I can put on this. The process is blended.
What matters more is where the responsibility sits.
I choose the subjects. I decide which arguments make sense. I test the code. I check claims and boundaries. I reject generated material that does not hold up. And I decide what gets published under my name.
If you want to see more of that process, I have a longer recording about how I combine human judgement with transformer models when creating technical content.
Watch the recording about my AI-assisted writing process
So are the articles “written by AI”?
I don’t think that distinction describes the process very well anymore.
Sometimes I write a paragraph and ask a model to challenge it. Sometimes a model gives me a structure and I throw half of it away. Sometimes we work through code together. Sometimes the real output is a question I had not considered.
AI participates in the process. Editorial responsibility stays with me.
That is also one reason I am open about using it. Software development is moving in the same direction. Pretending these tools are not part of the work does not help us understand where they are useful or where they fail.
How do you make sure AI-assisted content is correct?
The same way I want engineers to treat generated code: verification matters more than where the first draft came from.
For technical tutorials, I run the code and verify the behavior I am describing. I check current documentation for version-sensitive features. When something is experimental, uncertain, or dependent on a particular version, I try to say so.
This does not make every article permanently correct. Frameworks change, APIs disappear, and dependencies move.
The version and publication date are important anchors. If you find that an older article no longer works with a current release, tell me. Those reports are helpful.
What versions of Java and other tools do you use?
For new articles, I generally use current Java and Quarkus versions that make sense for the topic and pin important dependencies where reproducibility matters.
The same applies to LangChain4j, model runtimes, Kubernetes tooling, and other fast-moving technologies.
Do not assume that a command from a two-year-old article still describes the latest release. Check the versions used in the article.
For experimental and preview features, I call that out explicitly.
Is everything about Quarkus?
No.
Quarkus has been a major part of The Main Thread from the beginning, and there is a large Quarkus archive here.
But the publication is deliberately wider now.
Java, agents, developer tools, software architecture, AI-assisted engineering, specifications, review practices, security, and maintainability all belong here when there is something useful to explore.
Sometimes Quarkus is the implementation platform. Sometimes Java barely appears at all.
Is all the content free?
Yes. The publication is free to read.
Subscribing gets new articles into your inbox and is the easiest way to keep up with what I publish.
Sharing an article also helps a lot. There is no complicated growth strategy behind that. If something was useful to you, sending it to another developer is probably the best recommendation the publication can get.
How often do you publish?
There is no longer a forced daily schedule. For a long time, I published every day. After more than 500 consecutive daily posts, I changed that.
Now articles appear when they are ready.
That gives me more room for experiments, research, deeper technical work, and the architecture pieces that need a little more time before I know what I actually think about them. Subscribers receive new articles by email.
How can I find articles about a particular subject?
Use the site search or browse the topic and section pages.
Java, Quarkus, AI, agentic engineering, and related technologies have accumulated a fairly large archive, so search is often the fastest option if you already know what you are looking for.
The homepage is more curated. It is where I surface current work and some older articles that are still worth reading.
Can I suggest an article?
Please do.
Reply to one of the newsletter emails or open an issue in the The Main Thread GitHub repository.
Some of the best article ideas come from very specific problems:
“This works until I make the call asynchronous.”
or:
“The documentation says this is supported, but what happens when two requests arrive at the same time?”
Those are usually much more interesting than broad requests like “write something about AI.”
Can I comment or discuss an article?
Yes.
Articles have comments, and I read them. Comments have led to corrections, follow-up articles, and completely new experiments.
You can also just reply to the newsletter email. I read those replies too.
Can I use the code?
Most companion projects are published under an open-source license such as Apache License 2.0. Check the LICENSE file in the individual repository before using code in your own project.
Tutorial code is written to teach a specific idea. That does not automatically make it production-ready for your environment.
Read the surrounding article, especially the production and security sections. Copying the code without the constraints is usually the fastest way to miss the important part.
Can I quote or share the articles?
Yes.
Linking to articles and sharing short excerpts with attribution is absolutely fine.
For larger reproductions, translations, training material, commercial reuse, or republishing substantial parts of an article, please contact me first.
Does The Main Thread represent IBM?
No.
I work at IBM, and some of my work naturally influences what I am interested in. I also write about IBM technologies when they are relevant to something I am exploring.
But The Main Thread is my personal publication.
The opinions, experiments, architectural preferences, successes, and mistakes here are mine. They do not represent IBM or any other organization I work with.
Who is Markus Eisele?
I’m a Java Champion, developer advocate, speaker, writer, and I work at IBM.
I’ve spent more than 20 years around enterprise Java and software architecture. A lot of my work has involved the awkward space between what technologies promise and what happens after somebody deploys them.
That is still the part I find most interesting.
You can read more on the About page, or just start with an article and see where the thread goes.