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. They don’t get tired, and they can absorb a lot of context quickly—reading large codebases, drafting tests, fixing linter errors, regenerating documentation, and re-running builds. The thing they still 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 when the machine asks. The leverage has moved up the stack. The valuable work is less about typing the answer and more about choosing the right question.

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 code, the places where the system can break get mapped - invalid input, dropped messages, retried calls, corrupted state - and the design absorbs them. Standard data shapes are the digital version of standard parts. A 30 mm bolt fits any 30 mm thread anywhere in the plant. Anything irregular has to be cleaned up before it enters the assembly.

Healthy software talks. Heartbeats on the wire, status messages, audit log entries - a running system has a sound. Silence is never quiet operation; silence is failure. Singh instruments every layer not because monitoring is fashionable, but because a machine you cannot hear is a machine you cannot control.

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.

One result is speed. Cycles that used to take days because of human waiting time - review handoffs, status meetings, design clarifications - can shrink into hours when most of the conversation is model-to-model and the human steps in at decision points.

A modern language model is not a fact engine. It is a guesser, trained to pick the most plausible next word. When it invents - what people call hallucination - it is not lying; it is following the path of least resistance through its training data, and that path sometimes runs off a cliff. Telling the model to 'be more careful' does not change the shape of the path.

Singh's research project, io-gita, treats reasoning as a landscape instead. Concepts are valleys. Reasoning is the act of letting a question roll downhill until it settles in the correct valley. Two valleys are connected only if a real path exists between them, and every legitimate path is written down ahead of time. If the path from question to answer is missing, the system cannot traverse it. The hallucination becomes mechanically impossible, not merely unlikely.

The same idea generalises. Any time a model's output is checked against something verifiable - a contract, a schema, a deterministic test - its freedom to invent goes down and the trust you can place in it goes up. Reliability is a structural property, not a hope.

The cardinal sin of a careful engineer is endless polishing against a target that keeps moving away. 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, 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 its own scar tissue. Every lesson the work teaches is written back 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. The factory privileges what is written down over what is remembered.

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 leaves the studio, it has to clear four checks. The data used to tune the system and the data used to test it must come from different sources. The real algorithm has to run, not a shortcut labelled with the same name. The baseline has to be a fair comparison, not a weak version set up to lose. The sample size has to test the actual claim, not a question that answers itself.

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.