# When Speed Changes the Shape of Exploration AI shortens the distance between an idea and reality, but generation can now outrun experience. When production stops waiting for observation, speed produces repetition instead of discovery. ## Metadata - HTML: https://glenzli.com/en/notes/speed-matters/ - Markdown: https://glenzli.com/en/notes/speed-matters.md - Collection: Notes - Language: en - Published: 2026-07-25 - Updated: 2026-08-17 - Tags: ai, speed, exploration, judgment, software-engineering ## Content A very specific annoyance recently pushed me to build my own Lightroom alternative. Renewing Lightroom in mainland China remains unnecessarily awkward. At the same time, new AI and imaging tools have made Adobe's subscription bundle less attractive to me. The decisive reason was years of accumulated friction. Too many operations still take several detours. Some features look complete until real work reveals the missing inch. Capabilities I had wanted for years never arrived, and one workflow still meant moving through several applications. I was not trying to clone Lightroom. I wanted to rethink those problems together and build something shaped around my own work and today's technology. About three days later, the codebase was nearing 120,000 lines. The basic application worked. The GPU pipeline worked. I had also completed a structural rewrite because the first direction was wrong. One hundred twenty thousand lines are not one hundred twenty thousand lines of value. Three days cannot reproduce the reliability accumulated by a mature product. The interesting part was the loop: implementation, real execution, and architectural correction all happened inside three days. Even a large human team would struggle to compress that loop so far. Code is not the only constraint. Coordination, scheduling, division of labor, and every change of direction have costs. Now a direction that once required a long project can become real first and earn its continuation from evidence. Speed is changing more than development productivity. It is changing how ideas meet reality. ## The Slow Era A software idea once had to survive a familiar interrogation. How many people? How many months? Is there budget? What architecture? Which features are essential? Which ones must wait? Those were sensible questions because implementation was expensive. Many worthwhile directions died before practice. Validation cost more than the available time, money, or attention. Scheduling and opportunity cost filtered exploration before it began. Traditional development therefore placed judgment up front. Requirements should be clear. Design should be thorough. Architecture should settle early. A wrong turn affected many people and wasted far more than a few files. That style of work will remain. One of its assumptions will not: practice must be slow. ## Practice Catches Up If an idea can become executable in a day, judgment no longer has to operate entirely in imagination. We can test whether an interaction feels right, whether a photo-management scheme survives daily use, whether a rendering pipeline matters, or whether an elegant workflow is elegant only on paper—against real files, devices, and hands. AI can push a vague purpose into executable form: build the interface and data model, connect the imaging pipeline, handle errors, then move module boundaries when reality rejects the first design. The human does not specify every step. The human keeps deciding which result serves the purpose, which failure exposes a bad assumption, which change deserves to stay, and which direction should end. Judgment moves from a single decision before implementation to a continuous choice throughout it. Development begins to resemble an experiment: put a claim in contact with reality, then let the result shape the next claim. ## The World Did Not Accelerate Imagine an execution model embedded in hardware, producing one hundred thousand tokens per second. Reading code, editing, testing, diagnosing, and proposing the next change could approach a continuous loop. The exact number does not matter. Once waiting crosses a threshold, people change how they work. A modification that takes weeks is avoided. A modification that takes minutes invites comparison. Several architectures can coexist briefly. A failed structure becomes easier to discard. Refactoring stops being a special project and becomes part of thought. Architecture no longer has to prove that the first judgment was eternal. It has to survive changing judgment. But token speed is not world speed. Compilers take time. GPU work takes time. Importing raw photographs takes time. Color accuracy, long-term workflow quality, and edge-case failures require real environments and repeated use. The model can produce proposals faster. The world does not produce evidence at the same rate. The next problem lives in that gap. ## The Illusion of Progress AI accelerates inward generation. It can turn existing code, products, and knowledge into more plans, implementations, and combinations. Learning about the world requires outward experience, and experience remains slow. New ideas grow from long use, an accidental observation, a technical limit, or recurring friction with other people. Higher token throughput does not manufacture those inputs. When generation outruns experience, the system begins consuming its own output. Repositories grow. Pages multiply. Features ship. The motion looks like progress. Yet quantity of output and growth of understanding are different things. A product can add features without approaching the real problem. A person can implement ten ideas without seriously using one. Speed creates the appearance of abundance. Much of internet software already carries the family resemblance: similar interfaces, workflows, business models, and product language. New products arrive wearing another wrapper around a familiar logic. AI makes the copying cheap. Give a model a vague product goal and it readily supplies cards, accounts, an admin dashboard, and a prominent AI entry point. The result may be complete and runnable without containing a new observation. Products become one another's requirements documents. Competitors become the boundary of imagination. An industry can iterate furiously while the same object reproduces itself. ## Production Demands Ideas Human ideas are not an infinite backlog. They need life, use, and observation. If a feature takes hours while experience takes months or years, production eventually exceeds the growth rate of thought. Execution does not stop when the original problem is solved. To preserve momentum, people add features, search for directions, and manufacture the next task. The product changes because development must continue, not because anyone found a new problem. Speed stops serving exploration. Exploration begins serving speed. Teams watch what competitors shipped yesterday. Individuals ask the model for five more directions. Products add features because features can be added. Every cycle produces output without admitting new experience. Ideas dry up because observation never gets enough time to occur before production asks again. ## Judgment Is Not a Brake Judgment is not another word for caution. It does not stand in front of fast execution shouting stop. It decides what deserves acceleration, which results deserve preservation, when to continue, and when to return to the world and wait for evidence. Speed makes wrong directions cheaper to abandon. It also lets us enter more of them. Without judgment, a system can efficiently build something unimportant, rapidly fix a feature that should not exist, and surround a bad assumption with an impressive architecture. Code volume, polished interfaces, and feature count make convenient substitutes for understanding. Judgment separates new evidence from a new arrangement, real friction from industry habit, durable systems from experiments that should disappear after answering one question. Speed expands the choice set. Judgment decides whether the choices mean anything. ## Methods Become Coordinates Requirements, architecture, tests, review, and versioning do not lose meaning when execution accelerates. They take on more filtering and memory. Requirements preserve why the thing deserves to exist. Architecture allows reorganization when evidence changes. Tests prevent continuous modification from drifting away from the original problem. Review asks whether a feature belongs, not only whether it is well implemented. These methods once stood before expensive implementation as gates. They can now spread throughout fast practice, preserving evidence, detecting drift, and ending directions that have lost their value. They become coordinates inside exploration. Software becomes an exploration record too: attempted judgments, failed paths, features that survived use, abstractions that turned out to be unnecessary. Some experiments stabilize into systems with tests, migrations, documentation, and maintenance promises. Others answer one question and end. The easier production becomes, the more important deletion, abandonment, and closure become. ## Speed Cannot Replace Exploration When an idea can be practiced in a day, our way of exploring the world will change. Research questions become simulations and visualizations. Personal workflows can grow their own tools. Small private needs can be attempted without proving that a market exists. But buildable does not mean worth building. If speed only copies familiar patterns into more places, it expands sameness. Without time to use, observe, and form experience, fast execution keeps recycling old ideas. Speed matters because it shortens the distance between a judgment and reality. It tells us sooner whether something holds. It makes bad directions easier to leave. The important ability is not permanent acceleration. It is knowing when to act, observe, wait, and stop after acceleration becomes available. Speed changes exploration. Judgment decides whether anything new emerges. ## Related - [When Implementation Is No Longer Scarce](https://glenzli.com/en/notes/when-implementation-is-no-longer-scarce) - [Software Development in the AI Era](https://glenzli.com/en/notes/software-cognition-in-ai-era) - [When Software Time Begins to Loosen](https://glenzli.com/en/notes/software-time-loosens) - [AI Software Engineering Notes](https://github.com/glenzli/ai-software-engineering-notes)