Philosophy.

For most of software history, humans were the prime mover. We typed, the machine ran. Cognition flowed in one direction: a person turned an idea into syntax, line by line, while the computer sat idle waiting for keystrokes. Productivity meant typing faster.

Large language models change which side of the table is doing the work. Models do not get tired. They can read every file in a 50,000-line codebase before lunch. They can write tests, fix linter errors, regenerate documentation, and re-run the build forty times an hour. The thing they cannot do is decide what to build, why to build it, or when to stop.

That is the human role now — set the brief, write the contract, place the gates, and lift the override switch. A person who is still doing the syntax part of software has been quietly demoted by the model and doesn't know it. Singh's job is to operate at the altitude where the work is no longer typing — it is direction.

An engineer designing a gearbox does not start by listing the things the gearbox should do. They start with the loads, the temperatures, the bearings, the failure modes. The features come later, because the failure modes determine which features can survive contact with the world.

Singh writes software the same way. Before the first line of implementation, the surfaces where the system can break get mapped — invalid input, dropped messages, retried calls, corrupted state — and the structural integrity is designed to absorb them. Standard data shapes (JSON envelopes with explicit schemas) are the digital equivalent of standard machine parts: a 30 mm bolt fits any 30 mm thread anywhere in the plant. Heterogeneous data has to be ground to spec before it enters the kinematic chain.

Every running system also has an acoustic signature — the heartbeat on the wire, the cadence of state messages, the rhythm of the audit log. Silence on a healthy machine is never quiet running. Silence is failure. We instrument every layer for telemetry not because monitoring is fashionable, but because an unmonitored machine is by definition uncontrolled.

A single LLM in a sandbox is a brilliant intern with no peripheral vision. Give the same model six different roles — orchestrator, architect, quality gatekeeper, digital twin of the owner, independent verifier, executor — and let each role read the working state of the others, and the dynamics change. Conflicts get resolved before they become contradictions. A bad design is killed at the architecture review, not after a thousand lines of test failures.

This is the same trick a warehouse robot uses to avoid a forklift. LiDAR returns the position of the obstacle, the planner adjusts the trajectory, and the collision never happens. Singh's multi-agent mesh is the software version. Every gate is a sensor. Every contract is a lane marking. The agents arrive at consensus before the human arbitrator is needed, and the human stays where they belong — at the override, not in the queue.

The throughput consequence is visible. Cycles that used to take days because of human latency — review handoffs, status meetings, design clarifications — collapse into hours when the loop is mostly model-to-model and only periodically model-to-human.

A modern language model is not a fact engine. It is a probability distribution over tokens. When it makes things up, it is not lying — it is following the densest available path through the distribution, which sometimes runs off a cliff. Telling the model to 'be more careful' does not change the topology.

Singh's research project, io-gita, treats reasoning as a dynamical system instead. Concepts are basins of attraction in a high-dimensional space. Reasoning is gradient descent — letting a question fall through the energy field until it settles in the right basin. Two basins are connected only if a path exists in the topology, and that path is encoded explicitly in a sparse adjacency graph. If the geodesic from question to answer is missing, the system cannot traverse it. The hallucination becomes structurally impossible, not merely improbable.

The same principle generalises beyond research. Any time we can ground a model's output against a verifiable structure — a contract, a schema, a deterministic test — the model's freedom to invent goes down and the trust we can place in the output goes up. Determinism is a topology, not a hope.

The cardinal sin of a careful engineer is infinite optimisation against a target that recedes faster than the work approaches it. Spacecraft theory: the system has to be flawless before it can fly, every joint inspected to six decimal places, the mission slips a year, then five years, then the program is cancelled. The world never sees the machine.

Singh's brief is the world's best production vehicle, not the world's best racing machine that might one day exist. Fast, repeatable, deployable on real roads. The boundary is hard-coded: the project ships at the functional high-water mark — the threshold where one more week of polish adds approximately zero value to a real customer. After that, every additional minute is a charity donation to the engineer's perfectionism.

Ship, let the world find the failure modes that were missed, harden them into the next build, move on. This is what production engineering looks like when it is honest with itself.

An engineer who only remembers their own mistakes is a slow engineer. An engineer who has read every other engineer's incident report is a fast one. Singh extends this to the build pipeline itself.

Every regression, every race, every silently wrong default that gets caught in production becomes a Project Learning Ledger entry — tagged with a permanent code (CL-FAC-091, CL-FAC-177) and a test that asserts the failure mode never returns. The ledger is injected into the prompt of the next project. The N+1th system starts with all the scar tissue of the Nth.

The factory inherits Lamarckian-style — every lesson the work teaches is re-encoded into the architecture, into the prompts, and into the test suite before the next sprint begins. The bug ledger and the test suite are the same artefact. There is no oral tradition; there is no tribal knowledge; there is only what the factory has written down.

The strongest temptation in any engineering operation that ships fast is to inflate the numbers. 99% accuracy. 4,000 tests passing. Zero hallucinations. Singh refuses this. A number is only worth what it cost to measure, and a number that was generated under conditions that don't match production is worse than silence — it teaches a lie that contaminates every downstream decision.

Before any result is published — internally or externally — it has to clear four checks. The calibration data and the test data must come from different sources. The actual algorithm has to run, not a shortcut labelled with the algorithm's name. The baseline has to be a fair comparison, not a strawman tuned to lose. The sample size has to test the claimed mechanism, not a tautology.

When any one of those checks fails, the result ships with the label SYNTHETIC or LIMITED, and the failure mode is documented out loud. Singh does not impress with fabrication. The work either survives the test or it does not, and either way the answer is told straight.