Twitxy Saved

Ivan Milosavljević

@_The_Java_Guy_

I help Java developers write high quality software by using proper OOP, AI, modern Java, and the best libraries so they can unlock new career opportunities
Munich, Germany thejavaguy.org Joined April 2015
470 Following 336 Followers 1K Posts

Latest posts 5

Pinned post

Ivan Milosavljević @_The_Java_Guy_
X algorithm says that for small accounts "let's connect" posts have really high reach these days.

Are you new here? Building audience? Tinkering with AI? Founding a startup? Let's connect!

Especially if you're a:
✅ Developer
✅ Entrepreneur
✅ Creator
✅ Maker
✅ Designer
59 replies 0 reposts 42 likes 2.1K views View on X
Ivan Milosavljević @_The_Java_Guy_
If you want to start a software factory but you are unsure how, just read the @mardehaym post below 👇
Mark Ajzenstadt Verified account @mardehaym 18h
“Software factory” comes up on a lot of my calls this autumn. Ask people what they mean by it and you’ll usually get different answers.

So here’s what one actually is, it's made up of 10 parts:

#1 Intake. A status in your tracker starts the run. If the ticket doesn’t have acceptance criteria that code can check, it goes back instead of getting built.

#2 Spec and plan. Before writing any code, the run lays out what it will build and how. A person approves that plan in the ticket, while a misunderstanding still takes minutes to fix.

#3 The orchestrator. Every ticket goes through the same fixed steps, within a budget for CI runs, attempts, time and money. In our design, a run gets two CI runs. If the second is still red, it stops and leaves a report in the ticket.

#4 The sandbox. Every task gets a fresh sandbox, with no credentials inside and an allowlist for outbound connections. When the task ends, the sandbox gets thrown away.

#5 The gateway. Every model call in the company goes through one gateway you host. Each team and service gets its own key and spend cap. Switching models becomes a config change.

#6 Context. The agent uses a map of the code to see what depends on what, then pulls only what it needs. A huge legacy repo becomes a handful of relevant files.

#7 The gates. CI decides whether the work passes. Deleting a test sends it back. The agent can’t change its own rules, a review agent has to quote the code it flags, and a person merges every pull request.

#8 Evals. Prompts live in git. A prompt change only ships after it passes test cases built from real past pull requests.

#9 Measurement. Every change connects the session, commit, pull request, ticket and epic, so you can see what a feature cost and how long it took. Report this by team, never as a ranking of individual developers.

#10 The seats. Engineers’ own AI tools connect directly to their vendors. Track that usage through metadata only: who uses what and what it costs. No prompts or code.

A software factory takes a ticket in and returns a reviewed pull request. The work is split three ways: code handles every step it can check, agents handle the few steps that need judgement, and people own the spec, the hard decisions and the merge.

The rule is simple: if code can check it, code does it. An agent saying “the tests pass” doesn’t count. CI decides.

It helps to be clear about what doesn’t qualify. Giving every engineer an AI coding tool is useful, but that alone won’t take a ticket from intake to merge.

One agent with access to your repo gives you the loop, without the factory around it. A swarm sharing one long conversation spends tokens on every agent rereading everything.

And if the whole thing only works while your code and staging data sit on a vendor’s servers, you have a production line you can’t move.

Architecture, new domains, greenfield, big refactors, performance work and product discovery stay with people. The factory handles work that’s well specified and checkable, giving your seniors more time for the rest.

The slowest part, in my view, is #1. Most backlogs don’t have acceptance criteria that code can check. Rewriting those tickets takes time, and nobody volunteers for it.

One test I’d apply to any setup, including ours: if you stop paying the vendor tomorrow, does the factory keep running? If it doesn’t, you’re renting the production line.

TL;DR. Most of a software factory is the platform underneath the agent: a gateway, measurement, gates and evals. Build those first, on the stack you already own. Adding the agent is the easiest part.
View quoted post on X
Ivan Milosavljević @_The_Java_Guy_
@mattpocockuk slams it again. I wonder if this time next year we'll read "no-one is reading code anymore, and we are still figuring out what that means" 🤔
Matt Pocock Verified account @mattpocockuk 1d
A brief history of AI Coding since Nov 2025:

Nov 2025: Opus 4.5 releases, OpenClaw gets built
Dec 2025: community agrees that models get good enough to handle 95% of coding tasks
Jan 2026: Ralph loops get popular, early efforts on loops/orchestration
Feb: Everyone feels knackered, too much strategic decision-making, fears around cognitive debt begin
Mar: Skills explosion as community converges around easy-to-share processes (superpowers already ahead of the game here)
Apr: most SOTA devs haven't written a line of code in months
May: "The unreasonable effectiveness of HTML" - more interest in richer review surfaces
Jun: "Loop Engineering" wins vaguepost of the year, signals more hype around process
Jul: Every talk in every conference becomes "here is my software factory"
Aug: Opus 5 speaks incomprehensibly, interest in ASD-STE100 peaks
Sep: Grok Bot gets popular, more interest in long-running "manager" threads which retain context and delegate work
Oct: The promised speed gains haven't materialised, "dark factory" feels a long way off still
Nov: No-slop manifesto releases, reading the code still appears essential

TL;DR: no-one is writing code anymore, and we are still figuring out what that means
View quoted post on X