Ask a capable model to build a project management app.
It returns a dark sidebar, a row of metrics, a kanban board, an activity feed, and a settings page. The buttons work. The cards move. Nothing is broken. Nothing explains why this product should exist.
Now give the same model a purpose. A small team loses track of half-finished releases across five services. The product should show the difference between the intended release and production, name the owner, and offer a safe way back.
That promise changes more than the prompt. It removes the generic velocity chart and turns the activity feed into an audit trail. It requires the data model to keep intended and observed versions separate. A retried command must not apply the same deployment twice. If the cluster cannot be reached, the interface should show the last known state and its age, not a reassuring guess. Rollback belongs beside the failure, not three screens away.
An agent may write every line and draw every pixel. The percentage of generated code can remain one hundred. What changed is that the work acquired a standard.
A category is not an idea
“A project management app” names a category. It names no person, tension, opinion, or trade-off. A category can start a discovery process, but it cannot finish one.
A detailed prompt does not solve this by itself. A long specification can describe a pointless product with great precision. The idea lives underneath: a promise to make something useful or interesting for someone in particular. It gives the work a reason to exist and a reason to exclude what does not belong.
AI can help shape that idea. It can question the premise, find alternatives, combine unlikely directions, and turn a hunch into prototypes. The human need not supply every insight. Someone must still recognize which direction has life and reject the merely plausible ones.
The share of an artifact produced by AI is a weak proxy for quality. Provenance still matters for licensing, security, and accountability; it simply does not tell us whether the result is useful, coherent, safe, or reliable.
Cheap generation raises the duty to discard
At the artifact level, slop is output shipped without enough selection and verification for its purpose and stakes. At the system level, the same failure becomes an externality: producers distribute more than they have judged, so readers and users pay the filtering cost. AI did not invent deferred judgment. It made plausible output cheap to generate and distribute.
Cheap generation should therefore raise the obligation to discard. It makes exploration and rebuilding cheaper, but judgment, verification, and integration remain scarce. We can use that capacity to test ten directions and ship one, or make users filter nine unexamined defaults. AI amplifies the standard applied to the loop; it does not supply that standard.
Models are not neutral in this process. They have recognizable priors: familiar layouts, familiar abstractions, familiar prose. A vague request pulls toward them. Escaping them takes attention.
But a prior is not a destiny. The same model can generate a forgettable dashboard or an interface with restraint and character. It can produce a tangled wrapper or a system with clean boundaries and a thoughtful data model. “Considered” names a process, not a result. The quality test is whether the product solves its stated problem coherently, safely, and under real conditions.
Taste goes all the way down
Here, taste means cultivated judgment: the ability to see which choices support the product’s promise and which dilute it. Taste is broader than aesthetics, but it is not a substitute for expertise.
Product judgment sets the promise. Engineering competence makes it survive reality. Interaction judgment makes it legible, usable, and safe. Taste holds those disciplines to the same standard.
For the release tracker, knowing how to make retries idempotent is engineering competence. Seeing that safe retries follow from the promise of a safe way back is integrative judgment. The same promise demands answers when a network response is lost, a pod dies halfway through a job, the same event arrives twice, or a traffic spike sends thousands of requests toward shared state.
Those answers may require stable idempotency keys, backpressure, durable state, monitoring, and recovery. They also change the interface. An unknown deployment state must look unknown. A dangerous action needs deliberate friction. A failure should tell the operator what remains safe and what to do next.
Typography cannot rescue a permission leak. Perfect retries cannot rescue a product nobody needs. Polish comes from carrying one worthwhile idea through every layer without confusing visual taste for technical skill or technical skill for product judgment.
Agents can contribute at every layer. They can propose the promise, challenge the architecture, run load tests, inspect the interface, and revise their own work. The human role is not a mystical ability that models can never touch.
It is a position of consequence. The people shipping the product decide whose problem matters, which trade-offs are acceptable, what evidence is sufficient, and whether the result deserves other people’s attention. An agent can improve those decisions. It cannot relieve the maker of them.
The opposite of slop is not handmade
When a product feels human, we usually mean that it feels attentive: its defaults fit the job, its failures help us recover, and its details protect the same promise. None of this requires hand-typed code.
Let agents build aggressively. Generate alternatives, test them, and throw most away. The maker’s responsibility is to define what deserves to exist, verify it under real conditions, and absorb the cost of judgment before asking users for their attention.