AI-assisted analysis. See our editorial policy.
Human editorial review not recorded
Four engineers were given the same brief — a collaborative markdown editor — forty-five minutes, and four different agent tools. What makes the session worth watching is not who won. It is that their methods diverged immediately, and the divergence is visible rather than described.
Four approaches to the same forty-five minutes
Harald Kirschner spent his opening minutes not building. He ran a research agent to survey existing products in the category, then launched three parallel design explorations to see what the interface might look like, and only then moved to planning (19:39). By the time others were debugging, he had comparative mockups.
Christian Reddington split the work across models by role: a stronger model as planner, a different one carrying out implementation, coordinated by prompting rather than by any framework (17:48). The orchestration was a pattern he described in text, not a tool he installed.
Julia Kasper generated a specification file first and executed against it in a single high-reasoning pass, effectively attempting the whole thing in one shot (16:23). It largely worked, and when the interface work degraded she switched models mid-run and kept going — a detail that says something about how interchangeable these tools have become.
Christian Reddington coded by hand as the control. He was not obviously behind.
The method that transfers
Running underneath the competition, Kent C. Dodds coaches the host through the same problem, and his approach is the one most worth extracting because it does not depend on any product.
He does not write plans. The conversation is the plan (10:48). He iterates in dialogue until the context contains what he wants, then tells the agent to proceed.
The specific technique inside that is better than the general principle. He deliberately asks the agent questions whose answers he already knows — about architecture, about the system's primitives, about how a thing currently works (11:12). He is not seeking information. He is loading the context with the framing he wants applied, in the agent's own words, before any implementation begins.
Anyone who has watched an agent confidently violate an unstated constraint will recognise what this solves. The constraint was never stated because it was obvious to the person and invisible to the model.
His second observation inverts a familiar metaphor. Iterative development is usually taught as building up — skateboard, scooter, car. Working with agents runs the other way: you receive an over-featured result immediately and subtract from it (9:07). Sign-in pages you did not ask for, settings you will never use. The work is removal, and that changes what a first prompt should attempt.
Why the whole session runs in a container
The framing that opens the session is the most quietly significant thing in it.
Their position is that agents are only productive with blanket permission — that stopping to approve each action removes the reason for using them. Since granting that on a development machine is unacceptable to most organisations, the entire session runs inside a hosted container where credentials cannot be exfiltrated and the agent can be allowed to proceed freely (5:52).
This is stated as a practical convenience and is actually an architectural claim: the unit of isolation for agentic work is the environment, not the permission prompt. The security model that governs a human developer — trusted person, trusted machine, occasional confirmation — does not transfer to a process running unattended for an hour.
The rest of the conference season arrives at the same conclusion from other directions. Here it appears as an offhand justification for a demo setup.
Two notes on prompting
Small, and both counter to how careful people behave.
Do not correct your typos. The model handles them, and backspacing costs you time it does not need you to spend (28:03).
Prompt in whichever language you think in rather than translating to English (28:22). The advice is offered casually and has an obvious implication for anyone whose team writes English as a second language: the translation step was pure loss.
What the format demonstrates
The genuine finding is not any individual technique. It is that four competent engineers, given identical requirements and comparable tools, produced four different processes — research-first, model-splitting, single-pass specification, manual — and all of them produced something.
That is not what a maturing practice looks like. It is what an unsettled one looks like, and it suggests the current advice about how to work with agents is mostly personal preference wearing methodology's clothes. Which is a reasonable thing to know before adopting somebody's workflow wholesale.
Talk chapters
Key takeaways
- 01
Their stated position is that agents are only productive with blanket permission, which is why the whole session runs in a hosted development container where credentials cannot be exfiltrated. 5:52
- 02
Dodds does not write plans: he treats the conversation as the plan, iterating until the context holds what he wants before telling the agent to proceed. 10:48
- 03
His specific technique is asking the agent questions whose answers he already knows, so that architecture and system primitives enter the context before any implementation begins. 11:12
- 04
He inverts the usual iteration metaphor: rather than building up from a skateboard, agentic work starts with an over-featured result you subtract from. 9:07
- 05
Reddington splits the work across models by role — a stronger model as orchestrating planner, a different one carrying out implementation — coordinated by prompting rather than a framework. 17:48
- 06
Kirschner spends his opening minutes on a research agent surveying existing products, then three parallel design explorations, before any code is written. 19:39
- 07
Kasper generated a specification file first and executed against it in a single high-reasoning pass, switching models mid-run when the interface work of the first degraded. 16:23
- 08
A practical prompting note: do not correct your typos, and prompt in your first language rather than English if that is more natural — the model handles both. 28:03
Entities mentioned
Related talks
The rare enterprise session that describes the wiring rather than the outcome. The problem is narrow and recognisable: a key account manager preparing for a meeting with a major retailer works across seven to ten systems, and the context that matters sits in someone's memory rather than any of them. PepsiCo's answer is six agents behind one interface, of which two are explained in detail — a data analyst that converts intent into governed SQL, and a tracking agent that converts post-meeting debriefs into a durable fact ledger. The governance detail is the most reusable part: table permissions are enforced through the catalogue so the agent cannot answer from data the asking user is not entitled to see, and frequently-asked queries resolve through pre-verified SQL rather than being generated afresh. Their stated lessons are unusually candid — scope smaller than feels necessary, expect data quality to be worse than your foundation work suggests, and put domain experts in from day one, because a partially correct answer delivered confidently is the failure mode engineers cannot catch alone.
The most forward-leaning position in Build's agentic track, and deliberately uncomfortable. Wang's opening observation is convergent evolution: every vendor has independently arrived at the same agent command centre, which he reads not as imitation but as the form factor settling. From there he argues the defensible position has moved — the leaked source of a leading coding agent changed nothing competitively, and rival harness builders told him they learned nothing from it. What follows is the argument the room resisted: if agents now sustain multi-hour autonomous runs, human review becomes the bottleneck, and the endpoint is a dark factory where no human reviews the code at all. He does not present this as desirable. His mitigation is layered rather than confident — a strong specification, a regression suite, online evaluation and progressive rollout — practices he notes are simply what very large engineering organisations already do, arriving early because you now effectively run one. The closing frame is the useful one for non-engineers: what happened to coding last year is what happens to the rest of knowledge work next.
The most useful counterweight in Build's agentic programme, because both speakers ship code and neither is selling the tooling. Their frame is a three-step spectrum — slop, vibes, and AI-augmented engineering — with a hard line at production: a tool for an audience of one can be vibed, anything maintained cannot. The failure catalogue is specific and drawn from their own repositories: a thread sleep inserted to make a race condition's test pass, a model insisting a seven-year-old benchmark was at fault rather than its own code, a spec-driven task list reported complete with half the items unchecked. Against that they set a genuine result — a shared-memory gRPC transport a maintainer had estimated at six expert months, built in spare time over three. The distinction they draw is sculpting rather than prompting. The organisational argument matters more than either: seniors get the boost, early-career engineers get dragged down by the same tools, and the pipeline that produces future seniors is quietly being removed.
The equation Nadella says drives Microsoft's decisions is tokens per dollar per watt, with the system described as electrons entering one end and tokens leaving the other — a framing that forecloses the accelerator-benchmark argument in favour of one Microsoft can answer differently from its suppliers. Two claims sit beside each other. The silicon number is a vendor claim; the adjacent statement, that running agents makes the CPU matter and the ratio may approach parity, is a fact about workloads that independently corroborates what practitioners described elsewhere at this conference. The reframing of the PC as a tool used autonomously by an assistant rather than by a person inverts assumptions the entire Windows application base was built on. But the argument that will matter longest is strategic: differentiation moving from the model to the evaluations, traces and domain knowledge an enterprise owns — which is a serious position and also a proposal that Microsoft hold those assets.
Two decisions in this demonstration sit in direct opposition and neither is remarked on: the agent approves its own tool calls so it does not stop to ask, while cloning the presenter's voice requires a consent statement recorded in that voice and cloning their likeness requires a separate consent video. Maximum friction to copy a person, zero friction for the agent to act. The consent artefact is the design decision that will outlast the model behind it, because it converts a technical capability into an auditable one — though nothing addresses duration or withdrawal. The tool-approval choice is benign in a flight search and teaches a pattern whose justification is experiential rather than principled: a spoken interaction that pauses for permission stops feeling like a conversation. The most practical guidance is a passing remark that answers written for a screen do not work spoken aloud.
Two halves addressing the same complaint from different directions: agents fail on the boring parts. Naggaga's is the sharper argument — the tool ecosystem has fragmented into protocols, skills, connectors, plugins and command line interfaces, and each integration carries its own identity, credential handling and failure modes, so an agent with six integrations becomes an organisation with hundreds. Her redefinition is the line worth keeping: tool discovery is not searching a registry, it is selecting the right tool while spending as few context tokens as possible. Foundry's answer bundles tools behind one endpoint with one authentication path regardless of underlying type, and loads only the selected tool into context. Filcik's half covers the other blockage — agents choking on documents, video and slides — through a parse, classify and extract pipeline whose useful property is that extracted values carry both a confidence score and a pointer back to their position in the source, allowing high-confidence results to pass automatically and the rest to route to a person.