Writing

Why Explore became agent-accessible, and why profiles need to become agent-accessible too

Published: 2026-03-29

Explore started as a better proof surface for humans, but this post argues that profiles now also need to be usable by agents. It explains why Explore now exposes a public-safe inspection path, CLI, skill, owner-authenticated workflow, and draft-preview-apply model so profiles can support explicit inspection instead of acting only as polished presentation layers.

I’ve now pushed 1000+ jobs through my software factory.

Published: 2026-03-28

This post marks the 1000+ job milestone for Johnny’s software factory, arguing that it now feels more like an operating model than an AI coding assistant. It links that shift to agent-owned delivery responsibilities, a current self-assessment around Level 4.5/5, and the next hard problem: detecting architectural drift even when tests, CI, deploys, and smoke checks still pass.

At small scale, people can absorb workflow complexity. At larger scale, the workflow has to absorb it.

Published: 2026-03-24

At small scale, people can absorb workflow complexity, but at larger scale the workflow itself has to absorb it. It explains how operational pain is often misdiagnosed as a tooling or headcount problem, and argues for making state, actions, and next steps much more explicit. It also briefly mentions applying that thinking in a greenfield project first, then bringing the lessons back into a legacy monolith.

In complex systems, software dark factories do more than ship the change. The context they preserve around the change can be just as valuable as the code itself.

Published: 2026-03-23

This post argues that in complex systems, software dark factories create value beyond faster delivery: they preserve the decision trail behind a change, including the prompt, run log, verification, PR, and final code. That context becomes increasingly valuable over time because the hard part is often not reading the code, but understanding why it was built that way in the first place. The piece frames this preserved “decision memory” as a real engineering asset for both future engineers and future agents

Software delivery gets easier to improve once you make the timing visible.

Published: 2026-03-22

Recording delivery timing directly on the PR helps make the software delivery workflow visible, not just the final code change. By showing where time went across context gathering, implementation, verification, and waiting, PRs become workflow artifacts that make bottlenecks easier to spot and improve.

If your PR is the first time the change is properly validated, the feedback loop is too slow

Published: 2026-03-20

One simple dark factory win has been moving more verification earlier by running key checks locally before a PR reaches shared CI. Cloud CI still acts as the trusted gate, but it should confirm quality rather than catch obvious issues first. This improves iteration speed, reduces wasted CI usage, cuts queue noise, and increases first-time pass rates.

I’ve started treating agent friendliness as a core product feature, not an add-on

Published: 2026-03-19

I’m adding an agent manifest to a personal project so agents can understand product purpose, account state, available actions, next best steps, and guardrails. I think products will increasingly need to become legible to agents, not just humans or APIs, with explicit workflow, state, and safe actions. It fits the dark factory approach of clear contracts, explicit state, and fewer guesses.

Agentic development is the pair-programming model I actually wanted.

Published: 2026-03-19

AI made pair programming feel practical to me. Human pairing often felt too synchronous and expensive, especially in startup environments. Agentic development changes that by giving me an observable, steerable AI pair programmer that works from my playbooks and patterns, shortens the feedback loop, and keeps execution moving while I stay focused on intent, constraints, architecture, and judgement.

Most teams are not building software dark factories.

Published: 2026-03-18

Most teams are still layering AI onto old delivery workflows rather than redesigning the workflow itself around AI. The real shift comes from structured execution, validation, and evidence. What started as a greenfield personal-project approach is now being applied safely inside a legacy monolith, where the real bottleneck is not the model but the system around it.

Why put AI usage on the PR at all?

Published: 2026-03-13

Because once AI becomes part of delivery, the business question quickly becomes:what did this take, and what did it cost?For this slice, the PR includes:Current AI Usage in the PR: That is why I think it belongs on the PR.Not because the PR is necessarily the perfect long-term home for it.But because it gives both the reviewer and the wider business a useful signal tied to the actual delivered change.It is not perfect accounting.It is not the whole story.But it is enough to start creating a f...

Blockchain has gas fees. AI has token economics. Same underlying lesson: computation is not free.

Published: 2026-03-13

Blockchains made computation cost visible through gas. AI is doing the same through tokens, model choice, and reasoning effort.That is a useful mental model.In crypto, you do not send every transaction the same way.If it is low value, you want it cheap.If it is urgent, sensitive, or high value, you may pay more or choose a different chain altogether.AI is starting to look similar.A small, well-bounded task might belong on a cheaper model with low reasoning.A higher-risk or more ambiguous task...

If AI is helping write the PR, the PR should show how AI was used, how much effort it took, and what it cost.

Published: 2026-03-13

At some point, the business conversation stops being “this is cool” and becomes “what is this costing us, what is it saving us, and is it worth it?”Ultimately, it gets boiled down to the number that matters most: cost. I’ve started rolling out a lightweight way to show AI usage inside the PR itself.Not prompt theatre.Not vague “AI helped a bit.”Actual review-friendly signals on the change:preflight recommendation before the slice starts baseline snapshot taken before implementationdelta-based...

“Whatever mess AI gets us into, AI will get us out of.”

Published: 2026-03-12

“Whatever mess AI gets us into, AI will get us out of.”I hear that assumption a lot in business conversations.It hasn’t been my experience so far.The question I keep asking is:How do we get businesses to take AI-driven software risk seriously before they have to feel the consequences themselves?Unless you’ve lived through the fallout of fragile, revenue-critical systems, it’s easy to underestimate how serious this is. The people who haven’t felt that pain firsthand are less likely to put prop...

Don’t just tell the model what good code looks like. Show it, then make it prove it followed it

Published: 2026-03-11

Don’t just tell the model what good code looks like. Show it, then make it prove it followed it.

Codex “Fast” Mode Is Wild (and It Made Repo Hygiene Even More Important)

Published: 2026-03-10

I tried Codex “Fast” properly today for the first time.It’s… ridiculous. The speed feels like you’ve removed friction from the entire loop: ask → change → verify → iterate.

One of the quickest “AI productivity” wins in a monolith isn’t another model.

Published: 2026-03-10

It’s less noise, In the AI era, context is cost.I’m doing a sweep to remove dead repo assets (old CSVs/exports/screenshots/sample data) and trimming logs (lower verbosity + sensible rotation/cleanup).Why? Because in big codebases, context is cost:navigation/search gets harderagents pull in irrelevant filestoken/context burn goes upsmall changes stop being “small”So I’m treating repo hygiene + log hygiene as part of the “software factory” workflow:keep the working set tight → keep tasks cheap ...

Vibe coding is great for prototypes. Production needs discipline.

Published: 2026-03-08

LLMs can generate a lot of code quickly but the quality range is massive unless you force the work through guardrails.So I don’t ask my agent for “an answer”.I ask it to ship a solution through a playbook (built from ~20 years of patterns/practices I actually trust in production). The key rule:It must cite which playbook rules it applied and why, plus show verification evidence.

What’s next in the queue — and how does it move us toward the North Star?

Published: 2026-03-07

I ask my software factory:“What’s next in the queue — and how does it move us toward the North Star?”It replied with 5 small, verifiable jobs — each with a clear “why” (contract/telemetry, removing manual paths, hardening inputs, runner policy, cross-repo proof).This is the real agentic unlock for me:not “bigger prompts” — tighter slices + explicit intent + evidence.

I’ve updated my profile to “Software Factory Manager”

Published: 2026-03-07

AI hasn’t removed engineering work. It’s changed where the leverage is.Writing code is getting cheap.Trust is getting expensive.So my day-to-day is shifting up the stack:Turning intent into a spec (goal + acceptance criteria)Setting constraints + guardrails (what we will / won’t do)Insisting on verification (tests + CI as the gate)Making changes auditable (run logs, evidence, rollback paths)Breaking work into small, reversible slicesI’ve built an AI “dark factory” to support this with a playb...

I’ve started batching work through my software “dark factory”.

Published: 2026-03-07

Instead of running one job at a time, I queue a handful of small, reversible slices — and the factory sends back a single execution report when it’s done.That report includes:PR links (merged sequentially)exactly what shipped per jobverification commands + outputsthe prompt/run artifacts for audit + replay The mental shift: I’m not “reviewing more code”.I’m reviewing the contract + proof. Tests + CI are the gate.

One small change that’s made AI-assisted refactoring feel production-ready for me:

Published: 2026-03-05

My agent has to state which best practices it applied — and why.Not just “here’s the diff”, but “here’s the thinking”:what refactoring move was used (extract class, etc.)what rules/patterns it followedhow it kept the change small + test-backedwhat evidence it captured (tests/CI)It turns AI output from “looks fine” into something you can audit, review, and trust.Screenshot is a real example: the PR includes a “Playbook Compliance” section showing the practices applied for code quality.

From Novice to Senior: Refactoring a Whole Codebase Overnight With a Software “Dark Factory”

Published: 2026-03-05

I planned to extract the Dark Factory engine from my personal project as a standalone tool for work.But I wasn’t happy with the code standard — both the factory itself and some of the code it had produced. It was functional, but naïve.So I did something different.I used Codex plan mode to collate:the software engineering practices I’ve learned over the last 10–20 yearsthe external resources that shaped how I write maintainable codethe “playbook” standard I’d want in productionThen I fed that ...

The Hidden Cost of the God Table (and how AI can make it worse)

Published: 2026-03-04

Every production system has at least one “god table”.It’s usually the biggest, busiest table in the database — the one that knows about everything: orders, users, products, payments, delivery, invoices, discounts, status, audit trails… and inevitably, a lot more.It becomes a magnet for behaviour. And that’s where things get dangerous.AI accelerates this problem in a predictable way.Why LLMs grow the god table by defaultWhen you ask an LLM to implement a change, it will usually optimise for th...

The Most Underrated Scaling Pattern in Startups & Scale-Ups

Published: 2026-03-03

One of the most underutilised design patterns in startups and scale-ups is the adapter pattern.I used it today and it reminded me why it’s so valuable: it’s not just “clean code”. It’s commercial leverage.How lock-in happens (and why it hurts later)Early on, startups get generous free tiers and credits:AWS/GCP, map providers, email providers, analytics tools, Intercom, HubSpot, etc.It’s rational to move fast and take the free value.But as you scale you hit enterprise pricing, quotas, overage ...

My dark factory software workflow now has a UI.

Published: 2026-03-02

I’m trialling a simple flow where technical and non-technical teammates can request a factory job (e.g. “add an API endpoint”), and the factory turns that intent into:Scoped prompt spec (goal + acceptance criteria)Run log (commands/tests)CI as the gate (green or it didn’t happen)PR with evidence attachedDeployed to staging env for UAT Early days, but it’s an interesting way to put structure + guardrails around “vibe coding”.

Dark Factory: “No Humans Should Write Code” (and what it taught me)

Published: 2026-02-28

A few weeks ago I read Simon Willison’s write-up on StrongDM’s “Software Factory” approach. The line that stuck with me wasn’t even about agents or tooling — it was the mantra:Code must not be written by humansCode must not be reviewed by humansI found it fascinating… and honestly a bit uncomfortable.

Evidence > vibes.

Published: 2026-02-27

This is what I’m aiming for with AI-assisted dev: every job produces a small PR + CI green + a prompt spec + a run log (commands/tests) so you can audit what happened.Diff is output. Evidence attached.

I’ve stopped “prompting an AI” and started running a software factory.

Published: 2026-02-27

Every PR now includes:the prompt spec (goal + acceptance criteria)the run log (what the agent did + command/test outputs)the checks as the gate (CI green or it isn’t done)It turns AI work from vibes into something you can audit, replay, and trust:instructions in → software out → evidence attached.Screenshot is a real example: prompt + run log sitting right next to the diff.

I Thought AI Would Take the Fun Out of Engineering — It Didn’t

Published: 2026-02-26

I was worried AI would take the fun out of engineering. My early experiences felt a bit like “autocomplete on steroids” — faster, but less satisfying.It’s gone the other way.

AI Top Tip: No Green, No Opinion.

Published: 2026-02-19

When AI generates code, it can look convincing even when it’s wrong.So I don’t assess the implementation first. I run the specs first.In traditional development, you wouldn’t submit (or even entertain) a change that fails CI.

Your Next Customer Might Be an Agent: How to Prepare Without Panic

Published: 2026-02-15

There’s a lot of fear right now.People can feel the ground moving under how we work, how we buy things, and how businesses acquire customers. The questions are reasonable:What does this mean for my job?What does this mean for my business?Are websites and apps about to become irrelevant?This is my attempt to add some reality: where we are, where we’re going, and what to do next.Where we are (agents are useful, but still messy)Agents can already do a lot: find things, compare options, fill form...

AI Turns "We’ll Refactor Later" Into "Let’s Do It Now"

Published: 2026-02-14

Most software work starts the same way:get a happy-path flow workingsurface rabbit holes earlyproduce a first draftThen we all say the same thing: “We’ll refactor it later.”Sometimes that happens. A lot of the time business pressure wins, and the first draft becomes production.That’s not laziness.

Don’t Over-Determinise Agent Wording (Avoid Brittle If/Else Trees)

Published: 2026-02-14

When teams start writing agent instructions, there’s a very common instinct:Make the instructions “safe” by turning them into a big set of deterministic rules.It usually starts with something small, often around wording.For example:if a delivery date is in the past, say “was due”if a delivery date is in the future, say “expected”if it’s today, say something elseif the date is missing, choose a fallback phraseIt looks disciplined. It feels like you’re removing ambiguity.But this often creates ...

Writing Agent Instructions Is Programming

Published: 2026-02-14

When people talk about “prompting”, it can sound like the skill is writing clever English.But when you’re giving instructions to an agent that’s meant to do real work reliably, it feels much closer to programming than copywriting.You’re not just asking for an answer. You’re specifying behaviour.That changes what “good” looks like.Good agent instructions aren’t poetic.

PR Review Is Changing in the AI Era

Published: 2026-02-14

PR review was never really about the code.Yes, we look at the diff. But the real thing we’re trying to assess is judgment:did the engineer understand the problem?did they make sensible trade-offs?did they spot the risks?did they validate behaviour?did they leave the codebase better than they found it?The uncomfortable truth is: the final code artifact has never been the deciding factor on its own.

Engineering Interviews Are Changing in the AI Era

Published: 2026-02-14

Engineering interviews have always been a proxy.We can’t fully simulate real work in an hour, so we use exercises and questions to approximate signal:how someone thinkshow they trade off speed vs qualityhow they handle uncertaintywhether they validate and de-riskwhether they communicate clearlyThe final code someone produces was never the whole point. It was a clue.

Software Delivery: Appetites Over Estimates (and What You Say When The Business Asks “How Long?”)

Published: 2026-02-14

Most teams like the idea of “appetites over estimates” until you try to run an actual planning cycle.Let’s say you’re planning a 4-week cycle: 3 weeks of development and 1 week cooldown. You’ve got a set of pitches on the table.

Writing Agent Instructions Is a Team Sport (Business + Engineer)

Published: 2026-02-14

If writing agent instructions is programming, it follows that the best instructions aren’t written by one person in isolation.They’re a team sport.When I say “business” here, I often mean a PM — that’s how we do it. But it could just as easily be a founder, ops, customer support, or anyone close to the user and the outcomes.

Codex / GPT-5.3 feels noticeably faster and more accurate for me.

Published: 2026-02-14

The biggest difference is it pushes back. It flags risks, calls out contradictions, and suggests sensible alternatives, instead of the default "you’re absolutely right" even when I’m clearly changing my mind mid thread.It’s starting to feel like an actual engineering partner.

Planner/Worker: The Two-Thread Workflow That Keeps AI Useful

Published: 2026-02-14

One of the easiest ways to waste time with AI is to do everything in a single long thread.It starts well, then the context grows, quality drifts, and you end up with a messy mix of strategy, partial implementations, and conflicting decisions.You get “context rot”, but you also get something worse: you lose your own clarity.The approach that’s worked best for me is a simple two-thread workflow:one “planner” thread that holds the strategy and the big picturesmaller “worker” threads for discrete...

AI Top Tip: Context rot — stop fighting it, start a clean chat.

Published: 2026-02-14

When an AI thread gets long, quality drops.It gets slower, forgets earlier decisions, and starts confidently guessing.My reset prompt is:“Hey ChatGPT, I think you’re suffering from context rot. Can you summarise the key context from this thread so we can move to a fresh chat and keep the momentum going?”Then I paste that summary into a new thread and carry on.Same work.Cleaner context.Better output.

AI Hasn’t Fixed Estimation in Software Engineering - It’s Made It More Dangerous.

Published: 2026-02-07

Estimation in software has always been broken.Not because people are bad at it, but because we keep asking it to do something it can’t: predict outcomes in complex, uncertain systems.AI hasn’t changed that.What it has changed is speed — and that makes estimation more dangerous, not less.Speed increases confidence faster than understandingAI makes it easy to move quickly:code appears fastdemos look goodprogress feels visibleThat often increases confidence faster than it reduces uncertainty.You...

AI, TDD, and the Return of the Feedback Loop

Published: 2026-01-31

Lately, working with AI has reminded me a lot of how Test-Driven Development felt when I first learned it.Not the dogma.Not the purity debates.But the feedback loop.What TDD was really doing (for me)When I interview engineers and ask about TDD, I often hear the same answer:“It helps catch bugs.”That’s true but it was never the main benefit for me.The real value of TDD was the speed of validation.Writing a test forced me to answer a simple question early:Do I actually understand what I’m tryin...

Using AI to Build Around Tech Debt, Not Rewrite It

Published: 2026-01-24

Every startup carries tech debt.Not because teams don’t care — but because speed, uncertainty, and evolving requirements make it inevitable. Most of it never gets “paid down”, and full rewrites are usually too risky to attempt.AI doesn’t remove that reality.But it does change how we can move forward without being trapped by it.This pattern isn’t new — the leverage isLong before AI, people like Martin Fowler described incremental ways of dealing with legacy systems — most notably the Strangler...

AI Helps You Ship. Simplification Helps You Scale.

Published: 2026-01-18

AI has dramatically lowered the cost of building software.With agentic development, copilots, and increasingly capable models, it’s never been easier to go from idea to working implementation. You can explore solution space faster, test assumptions sooner, and ship proofs of concept in days rather than weeks.That’s a genuine shift — and a powerful one.But there’s a pattern I’ve seen repeatedly in startups (and honestly, in any business trying to solve something genuinely hard), and AI is acce...

Agentic Development: The Shift Is Already Here

Published: 2026-01-10

Agentic development has improved massively in the last six months. In the summer of 2025, I tried using Copilot to build a moderately complex feature.

Appetites, Project Deadlines, Due Dates...

Published: 2022-10-14

When scoping/planning development work for the engineering team the first question from the developer is always: When does this have to be done? How long have we got?

Bugs Within The Software Development Life Cycle - How Best To Manage?

Published: 2021-05-22

Regardless of the engineering teams competency bugs are part and parcel of the life cycle of every software development project.  Within the software development paradigm there are best practices for nearly every part of the development life cycle except bug management. I have participated and witnessed several different approaches over time but there doesn't seem to be much around best practices.Common ScenarioA bug is reported either directly(customer support, internal employee, client etc)...