One year ago, in Collective Awareness and the Era of Automated Production, I watched the cost of producing software fall below the cost of understanding it. Code could arrive before a person had finished reading the request. I expected people to keep scope, review, and approval while agents took on scaffolding, tests, and background tasks. The bottleneck was moving away from typing and toward judgment.
The shift I can see a year later is quieter and more extensive. It has entered the grain at which I give attention to a product. Earlier, I carried an intention through the computer in tiny deposits. It entered a character, an identifier, a condition, a query, a margin, a transition, an error message, a deployment step. Each layer needed enough care before the result could appear, and the whole product waited somewhere above that passage.
Now I can state a direction and receive a working branch containing source, scripts, tests, configuration, documentation, and build artifacts. Tool calls continue while my attention moves elsewhere. I return to a bundle of decisions already expressed in files. I may open any one of them and work directly on a character, and much of the production no longer requires that journey from me.
This changes the distribution of intention. The earlier process sprayed it in a fine mist across every layer. Generative production can concentrate it around purpose, constraints, comparison, verification, and the final experience. That concentration creates room to become the owner of the whole product. It also makes such ownership harder to avoid.
The grain of the gesture
Programming and coding name different kinds of work in this essay, even when one person performs both. Programming arranges behaviour: data, relations, control, timing, constraints, interfaces, failure, and effects. Coding shapes one material inscription of that arrangement in source text, down through files, blocks, lines, identifiers, punctuation, and characters.
People have programmed through coding for so long that the two words often occupy the same place. The practice itself has always contained larger gestures. Copy and paste moved a block without retyping it. Search and replace applied one decision to many occurrences. Perl and other scripting languages turned a repeated edit into a program of its own. Editors and IDEs added completion, macros, structural navigation, refactoring, templates, and code generation. A rename could travel through a project while the programmer held the identity of the symbol and the tool carried the textual changes.
A person could be hired to code and regard the assigned change as the whole job. The result could still be called custom because it lived in one customer's repository and bore local adaptations. Its material might have come from a remembered lecture, a book pattern, a copied block, an answer found online, or a framework convention. Empirical studies have traced this ordinary reuse in IDE copy-and-paste behaviour and in fragments shared between Stack Overflow and GitHub (Ahmed, Shang, and Hassan, Huang et al.). Manual inscription gave every line a local address while originality and care for the whole product remained separate questions.
Package ecosystems enlarged the gesture again. RubyGems distributes packaged libraries, while Bundler records an application's dependencies in a Gemfile and resolves the set needed across environments (RubyGems Guides). A single declaration can bring a large body of ready-made behaviour into an application. Some gems also bring generators and templates. The short declaration leaves integration, compatibility, upgrades, and production behaviour with the resulting program, yet the programmer receives a capability without inscribing its internal lines.
Generative AI extends this history through a different kind of continuity. A model-and-tool loop can write the script that transforms a repository, run it, inspect the result, change the source, create tests, update configuration and documentation, invoke another tool, and return the whole change for review. The operated unit has grown from a character to a run of production.
The discontinuity lies in the size of material a person can accept at once. A copied fragment typically entered a sequence of adaptation through local names, types, neighbouring code, compiler errors, and deployment. A generated run can perform that adaptation and present source, tests, configuration, and explanation as one proposal. The operator begins review after the material already has the shape of a solution.
Each earlier layer remains available. Direct coding becomes a chosen depth of intervention. It will continue as a niche skill for exact control, difficult repairs, teaching, investigation, and pleasure, open to anyone who wants to practise it where the source and tools are available. Some people will spend an evening tuning an allocation, rewriting a parser, or aligning a visual edge one value at a time because the contact itself matters. Others will enter through a task, a conversation, or an orchestration surface and still perform programming by arranging what the system must do, what it may change, how it will be tested, and which result will be admitted.
Programming therefore continues. Its centre of effort can move while code remains one of its materials. The editor and IDE become available inspection and intervention surfaces within a wider production environment; they cease to be the compulsory passage for every artifact.
A custom surface on a generic machine
From the self-service side, software now feels more customizable than it did before. A person can ask for another tone, layout, image, report, workflow, or behaviour and receive a new instance immediately. A conventional application would have exposed a finite menu of settings or required another development cycle. Generative systems can interpret requests whose variations were never named in a settings panel.
That flexibility is real. It can grow at the same time as the underlying software becomes more generic. The same model, runtime, interface, policy layer, and tool system serve many people and situations. Each encounter supplies context, preferences, files, permissions, and a request; the common apparatus produces another local instance. The result may be singular while the machine behind it is shared.
This is the apparent contradiction at the centre of generative self-service: more individualized results can arrive through less bespoke software. A result made for one moment can remain an instance of a system built for everyone. Its storage, failure behaviour, permissions, continuation, and available forms of revision may still belong to the generic service. The surface can answer me closely while the machinery remains substantially the same for everyone.
I think of these outputs as probabilistic generics. The language model inside a coding agent assigns likelihoods to possible continuations, while decoding affects which path becomes visible (Holtzman et al.). Instructions, retrieved files, tool results, test failures, and further turns condition the next proposal. A longer reasoning-and-tool chain can search farther and fit the result more closely to one repository while the apparatus stays shared.
By good average I mean the ordinary offer: a plausible, context-fitted version of patterns made likely by training and preference shaping (Ouyang et al.). A fresh byte sequence may be unique while its governing idea remains conventional. Innovation still needs evidence in the idea, the changed relation, or what becomes possible in use. Complexity of the chain measures neither novelty nor value.
One short-story experiment gives a narrow warning about confusing local novelty with collective variety. Anil Doshi and Oliver Hauser found that access to generative suggestions raised individual story ratings, especially for participants who began with lower measured creativity, while the assisted stories became more similar to one another (Science Advances). Software is a different practice, and the study establishes no general law about generated products. It does show how individual improvement and collective convergence can occur together.
The useful distinction is where the decisions reside. A bespoke construction can borrow almost everything and still distribute its final decisions through local structure and behaviour; an individualized instance resolves many of them inside a common capability. Either can fit a person closely while placing that person's intention at a different depth.
I call this movement intention compression. More prepared machinery sits behind fewer acts by the operator, so each act carries greater leverage. Intention gathers around the request, supplied context, constraints, selection, correction, and use. Decisions still exist in the lower layers. They may have been made by framework authors, package maintainers, model builders, tool designers, training collections, earlier code, inferred convention, or the generated run itself.
Compression therefore has a direction. It moves some choices away from the immediate operator and makes the remaining choices heavier. A broad instruction can now touch hundreds of files, several representations, and a running service. The sentence at the top of the process may be short because a large technical and cultural apparatus waits beneath it.
More branches than a team can inhabit
The most important new affordance may be variation. When one candidate is cheap, several candidates become plausible. An agent can attempt a narrow repair, a structural refactor, and a change built around a missing boundary while other work continues. A person can compare the behaviour, read the consequences, and keep the solution that fits the product.
Software products now advertise this concurrency directly. GitHub's coding agent works in the background, prepares pull requests, and can run multiple tasks in parallel (GitHub). OpenAI introduced Codex as a cloud agent able to run many isolated tasks at once, later adding simultaneous responses for one task so a person could explore several solutions and choose among them (Codex launch, Codex changelog). These vendor descriptions establish that parallel production is a product form. The value of each result still requires independent evidence.
Before this form, a large team could technically open many branches, and human concurrency was expensive enough that most variations had to justify a person, a schedule, communication, and a place in the merge queue. The practical concurrency now available to one operator would once have required several people to hold several attempts at the same time. Each alternative occupied memory. People had to explain its assumptions, keep it current while nearby code moved, review its interactions, resolve its conflicts, and accept the opportunity cost of paths that would be discarded. Even a well-funded team had reasons to reduce the number of live alternatives early.
Agent runs lower the production cost of keeping several possibilities alive. This gives a product a better chance of encountering the solution that actually fits, especially when the candidates embody genuinely different approaches and can be exercised against real criteria. One variant may reveal a boundary that the first solution crossed too casually. Another may preserve compatibility. A third may show that the request itself was shaped around the wrong abstraction.
The conflict returns at comparison and integration. Isolated worktrees prevent two runs from overwriting the same local files, while the product still has one architecture, one vocabulary, one deployment path, and one future maintenance burden. The alternatives may disagree about types, dependencies, migrations, interface language, or the meaning of the requirement. Tests can reject some of them. A person or collective must still understand enough of the product to decide which disagreement matters.
Abundant variations provide a search field. They provide no automatic criterion for choosing within it. If the reviewer asks only whether each branch passes its own tests, several incompatible local successes may survive. If the product has clear constraints and observable needs, parallel generation can expose useful differences before one approach acquires the inertia of implementation. The gain comes from combining breadth of production with depth of evaluation.
That combination has no single productivity number. A randomized study with 96 Google engineers estimated a 21 percent reduction in task time, with a wide confidence interval (arXiv). Three field experiments involving 4,867 developers estimated 26.08 percent more completed tasks, with a 10.3 percent standard error and larger gains among less experienced developers (Management Science). In another randomized study, 16 experienced open-source developers working in familiar repositories took 19 percent longer with early-2025 AI tools, although they believed afterward that the tools had made them faster (METR). Later METR work found that concurrent agents, task substitution, participant selection, and time spent on other work made a newer speed estimate unreliable (METR, 2026).
These findings describe different tools, people, tasks, and measures. Together they show why perceived acceleration, production volume, task completion, and product value need separate accounts. A system can make three branches arrive quickly and make the final decision more demanding. It can also solve routine work quickly enough to release genuine attention. The result depends on where the saved attention goes.
The ticket beside the diff
The first things I now recognize as ticket systems were the work journals of my grandparents. I met a digital ticket system myself between 2010 and 2012, working in telephony and internet customer support. Opening it was the norm, and checking in and out also entered the calculation of pay. I arrived early, checked in, took cases from the queue, connected to equipment consoles to inspect hardware, called customers when a case required it, and checked out when the day closed. Redmine came later, when the ticket sat beside source code.
Across those forms, the record kept a working relation available beyond one action. I still remove tickets and branches when the work no longer needs them; what matters is what they held long enough for people to continue: a request, a consequence, a promise, and a decision about what happens next.
A ticket has durable jobs. A qualitative study of small, co-located software teams found issue trackers serving as organizational memory, communication hubs, and boundary objects through which support, quality assurance, developers, managers, and customers could work on the same concern (Bertram et al.). The support queue gave those jobs a daily shape: priority, customer history, service commitments, ownership, and hand-offs had to remain visible. One person might hold the formal assignment while several people investigated, observed, and contributed, learning the case together so its continuation depended less on one person's presence.
Feature work changes the relation between that record and the product. A ticket describes a possible future; a diff puts one future into the present, where it can meet the repository, tests, interfaces, customer, and people who will maintain it. In the manifesto for collaborative concurrent extreme development, initiative and delivered solutions create situations. The phrase is literal here. A branch is an intervention in a shared environment, and the replies, failures, corrections, silences, side effects, and new proposals around it become knowledge that the ticket could not contain in advance.
The branch belongs to a wider family of acts that learn by changing the field they observe. Political actors have long used this structure. A preliminary policy floated through mass media can measure the cost of opposition before anyone accepts formal ownership; a recent study analyses Donald Trump's Twitter posts as trial balloons used to observe reactions from the public, elites, and media (Escribà-Folch and Timoneda). Counterintelligence guidance from the US Department of Homeland Security warns that deliberate false statements and assumed knowledge can draw denials, corrections, and further disclosure (archived brochure). The forms range from open consultation to covert elicitation, and each inserts something into a social field so that the movement around it can be read.
Mass and social media carry this reconnaissance much farther. Information operations may use fabrication, altered authentic material, impersonation, reframed context, or coordinated amplification; the governing act is manipulation of the information environment, which extends beyond the truth value of one message (Council of the European Union). Reflexive control names a stronger form in which prepared information is used to alter how a target perceives its choices and reaches a desired decision (Till). A rumour, leak, partial disclosure, or false story can therefore be poor evidence about its ostensible subject and rich evidence about the field it disturbs: who corrects it, repeats it, coordinates around it, distances themselves, or waits.
Richness still needs an account of how the evidence was made. The observer creates part of the event and may change the people being observed; a participant-observation study found this reactivity in one of four classrooms (Hay, Nelson, and Hay). Response and non-response carry the same difficulty. Silence may come from ignorance, refusal, caution, fear, overload, a broken channel, or strategic delay. Even survey research, where the categories are more controlled, warns that a response rate alone cannot determine non-response bias without evidence about how respondents and non-respondents differ (AAPOR). A reply tells us what someone chose to do under this stimulus; silence leaves several live explanations.
A responsible product proposal makes its intervention visible. People know they are encountering a candidate, can inspect its assumptions, and retain practical freedom to correct, reject, or leave it unanswered. The branch stays bounded and disposable, with tests and observation separating what the artifact demonstrates from what the team merely inferred from the reaction. When a proposal masquerades as a settled decision or a false premise is used to extract an involuntary correction, the product team has crossed from shared inquiry into manipulation.
A customer request arrives in language before it has met the running product. I can give one reading of it a temporary body in a branch: source, tests, a screen, a preview link, perhaps a short video. Within an hour, sometimes while the conversation is still open, the customer can encounter that reading and point to where it bends away from the need. The same encounter exposes assumptions, integration costs, awkward interactions, and risk. The branch may disappear after doing this work, while its diff has already shown which files, concepts, interfaces, and tests the next decision will disturb. Wrongness becomes specific enough to revise, price, or use as evidence that another investment is necessary.
Some work begins and remains in a ticket. Support waits for a person, an external event, a permission, a shipment, an investigation, or a reply; the queue and assignment are the operation. Product discovery may need consent or observation before any responsible code change exists. For a feature whose behaviour can already be tried, or a bug that can already be reproduced, an agent can produce the first variation while people interpret the response, compare consequences, recognize risk, and decide whether the change belongs.
This is politics at its ordinary scale. People decide whose description receives time, which uncertainty becomes a shared risk, whose correction redirects the work, what silence is allowed to remain ambiguous, and who must live with the result. Elections, parties, and mass media formalize part of a field already present in workplaces, communities, conversations, and platforms. Creating a situation is a way to enter that field and learn from it; participation also makes the initiator responsible for what the situation does to everyone inside it.
Fast artifacts can deepen personal collaboration among professionals who still talk to one another. Several people can inhabit the same ticket and proposed change, speak while it runs, and leave with knowledge that no assignment field contains. Another person has heard the reasoning and touched the result before anyone becomes unavailable. Production becomes quick enough for the encounter to stay on the product and on the people who must continue it.
The same abundance can produce an organization of bots. I have every practical chance to assemble what I think of as a consumer bot net, and I do not want it. I expect 2027 to bring many such personal fleets because vendors are already packaging agent participants and coordination for ordinary use. Ten agents can fill ten branches before the people involved have built one shared understanding.
The value of branches and tickets is relational. A branch earns attention by making a conversation testable; a ticket earns attention by holding a queue, promise, or hand-off. I have been through the urge to preserve both as proof that work happened, and I prefer to delete them after they have carried the encounter. Communication continues in the product and among the people who must live with it.
The one-button instrument
A one-button synthesizer makes intention compression audible. One press can release a signal path whose oscillators, envelopes, filters, modulation, effects, gain staging, and perhaps arrangement have already been composed into the instrument or preset. The player chooses the entrance, duration, relation to other sounds, and response to what happens next. A small surface can carry an immense prepared interior.
The musician's attention lives in timing, selection, relation, and response, none of which can be counted from the number of controls. The instrument builder, sound designer, preset maker, and player participate at different depths and times. A musician may build an oscillator from components, patch a modular system, turn several knobs, or press one control whose consequences have been carefully heard. These practices can coexist because the musical decision and the electrical inscription occupy related layers.
Low-level coding is moving toward a similar place. It becomes a particular form of contact with the computational material, available when precision, curiosity, repair, or enjoyment calls for it. The generative surface can meanwhile operate a prepared stack through a smaller number of higher-leverage instructions. One button may generate a large artifact; the programmer still decides when it belongs, what it meets, how it behaves, and whether the product should continue in that direction.
This analogy also shows where genericity enters. A preset is reusable, and each performance can remain particular. A generative system reaches a much larger field of outputs through the same relation. It offers variation through a shared instrument and places the burden of musical continuity on the person shaping the whole passage.
Attention at product scale
Generated low-level work carries technical debt forward. Existing compromises remain in the repository, and new artifacts can add their own. The operator can now cross those layers without spending intention on every local inscription before seeing the result.
That possibility can raise attention toward product strategy: the reason the product exists, the experience it creates, the people it affects, its behaviour in production, its maintenance, cost, risk, and direction across releases. It can also be consumed immediately by more output. A person who once shaped one branch line by line can now supervise ten branches with the same hurried glance. Intention becomes concentrated only when someone protects it from the new volume.
Whole-product ownership names that protection. I use the phrase for a sustained relation, separate from any formal Product Owner role. The owner uses the product, lives with its rough edges, recognizes when a locally impressive change harms the whole, and stays near the consequences after release. Ownership includes the authority to stop production, discard a plausible result, reopen a settled direction, and spend time on an experience that cannot be inferred from a passing test.
Product love belongs here as practical custody. Love means continued use after novelty, attention to what the product asks from people, memory of why its strange decisions exist, and willingness to correct it when successful local changes pull it apart. Generated artifacts become cheap enough to accumulate without attachment. Love keeps the product from becoming a warehouse of individually acceptable decisions.
For me, slop has ceased to exist as a professional category. The word records disgust and supplies no measure of a defect, its consequence, or the work required to remove it. I use generic, template, and average when those are the observable properties; average digital material is often adequate. Garbage becomes a practical claim only when someone names the harm and takes responsibility for cleaning it; for me, that means entering the territory and operating there.
The tools have become software: ordinary enough to buy, schedule, complain about, depend on, and review. Acceptance remains uneven. In Stack Overflow's 2025 survey, 84 percent of respondents used or planned to use AI tools, and 52 percent said AI tools or agents had positively affected their productivity. At the same time, 46 percent distrusted output accuracy and 33 percent trusted it; agent use at any frequency reached 30.9 percent, and 37.9 percent had no plans to adopt agents (survey, methodology). Use became easier to normalize than trust.
That gap is productive. It keeps review visible as a real activity. Responsibility stays with the people and institutions that admit a result into the product, provided they have the time, knowledge, authority, traceability, and freedom to refuse. A review queue alone supplies none of those conditions. The operator can sign a change whose decisive assumptions were fixed earlier by a model, a tool, a policy, a dataset, or the structure of the request.
The far edge of delegation
Weapons make this problem impossible to treat as a metaphor about convenient software. They are a boundary case because compressed intention meets irreversible action. The terminology matters before any comparison begins. An uncrewed aircraft has no crew aboard and may still be remotely operated. An autonomous weapon, in the ICRC's functional description, selects and applies force after activation in response to sensor information and a target profile (ICRC). Artificial intelligence may participate in those functions; autonomy can also be implemented through other rules.
The United Nations is a forum for negotiation and norm formation in this field. In September 2026, the Convention on Certain Conventional Weapons group was still formulating elements of a possible instrument. Its working text recorded broad support for keeping responsibility and accountability with states and people throughout a weapon system's life cycle, together with a responsible chain of human command and control (2026 working text).
Other institutions place acceleration and restraint in different arrangements. NATO's revised AI strategy calls for faster adoption while retaining lawfulness, responsibility and accountability, explainability and traceability, reliability, governability, and bias mitigation (NATO). The European Parliament has called for an international ban on weapons that lack meaningful human control over target selection and attack, while the EU AI Act excludes systems used exclusively for military, defence, or national-security purposes from its scope (European Parliament, AI Act). The United States Department of Defense directive on autonomous weapons requires systems to allow commanders and operators to exercise appropriate levels of human judgment over the use of force, while its definitions and review process contemplate autonomous selection and engagement after activation (Department of Defense).
All of these formulations leave difficult work inside the word appropriate. A final authorization cannot recreate distinctions that vanished earlier in sensing, classification, ranking, timing, or interface design. Meaningful control depends on the field made visible to the operator, the time available, the system's predictability, the scale of simultaneous events, the possibility of intervention, and the institutional permission to refuse. Responsibility belongs across the chain that designed, procured, configured, deployed, supervised, and used the system.
The same structure appears at lower stakes in ordinary generated production. A person remains responsible for a product only while the review surface preserves the distinctions needed to act. Once output volume exceeds the ability to understand consequences, a final click becomes a record of authorization with a thinning relation to judgment. Concentrated intention needs concentrated awareness.
Direction after the diff
The computer still contains every character. Someone can still enter at that depth, and learning to do so remains one of the clearest ways to understand the material. Yet a programming act can now begin above the diff and remain there through much of production. It can establish a purpose, set boundaries, generate several approaches, exercise them, compare their consequences, and admit one into a product without requiring a human hand on every textual shape.
This distance creates a larger field of action. It also places more weight on direction. Strategy becomes the place where intention can remain coherent while artifacts multiply. Product use becomes the place where a polished output meets duration, inconvenience, maintenance, and people. Review becomes the place where a possibility either acquires consequences or is allowed to disappear.
The generic machine can produce more versions than a team once had the attention to make. Many of its probabilistic generics are variations within a learned field, intimately fitted to a moment. Their abundance gives us a better chance to find a suitable working solution, as long as selection remains connected to the product that must live with it. The human contribution gathers in the continuity among those moments: remembering the purpose, choosing a direction, using what was made, and staying long enough to answer for what all the generated parts become together.