Practice ·
If AI wrote the code, where is the author?
AI can write much of the code, propose an interface structure, prepare copy and find an error. This raises a direct question: when execution is delegated to a model, what remains with the author? I do not locate authorship in the number of operations performed by hand. It appears in the Concept, the system of decisions and the responsibility for the form that enters the world.
Authorship is not the same as manual labour
An architect does not lay every brick, an industrial designer does not necessarily stand at the machine, and a director does not hold every camera. Their authorship does not disappear because execution is distributed. It remains in the relationships they constructed, the constraints they accepted and the reasons the result took this particular form.
A digital product has long been associated with the direct act of writing code. A model that can produce code therefore appears to replace the author. Yet program text is only one material of the project. A problem exists before it; verification, release and the consequences of use come afterwards. Between those points lie decisions that cannot be made merely through the ability to generate something.
The Concept provides direction
A model can propose dozens of versions of one screen but does not know which one continues the original intention. It can extend a feature list without recognising when another capability destroys the product’s clarity. It may find a technically correct solution without understanding that its cost, dependency or handling of data contradicts the task.
The author defines whom the product serves, what change it should produce and what it must preserve along the way. This frame limits an infinite field of possibility. Without it, the speed of generation creates noise rather than freedom.
I therefore see a prompt not as the act of authorship itself but as one way of communicating intention to an executor. A well-formed instruction matters, but the system from which it comes matters more: the person’s journey, the data architecture, the visual language, known risks and the criterion for an accepted result.
A decision is revealed by refusal
Authorship becomes especially visible through what a person declines to add. AI readily continues: another screen, another animation, another integration, a more elaborate infrastructure. Each proposal can look reasonable in isolation and damage the whole when combined with the rest.
Refusal requires a position. Do not add registration before the main journey needs it. Do not turn a website into an entire application at once. Do not connect an external service when the dependency costs more than it contributes. Do not replace an expressive detail simply because a standard component is easier to implement. These decisions rarely produce more code, yet they preserve the product’s character.
In object design, material resists physically: concrete has weight, steel has thickness and production has tolerances. The digital environment seems infinitely pliable, which makes voluntary limits even more necessary. The author creates them where technology itself prohibits nothing.
AI becomes an environment of execution
In my work, a model may research options, assemble a prototype, write code, inspect pages, find discrepancies and prepare documentation. Several such processes may run in parallel. This changes the scale of what one person can make, but it does not remove the need for a single direction.
To keep the result authorial, I separate execution from decision. A model may propose; acceptance requires understanding. It may test a stated criterion; the criterion itself comes from the task. It may report that the work is finished; readiness is established only through the real scenario.
AI then stops being a conversational partner to whom the same wish must be retold and becomes a production environment. That environment needs project memory, access boundaries, checkpoints and a way back to a known state. The more autonomous the execution, the more precise the structure of responsibility around it must become.
Responsibility completes authorship
The simplest way to locate the author is to ask who answers for the result. Who verified that the product does not lose data? Who decided which information may leave for an external service? Who accepted the cost of a dependency, the recovery method and the tolerable boundary of failure? Who will revise the decision after it meets real use?
Referring to AI answers none of these questions. A model does not own the consequences merely because it produced the code. Responsibility remains with the person who chose to release the system and offer it to others.
Within the Method, I keep the articulation of the Concept, the choice of medium, the architecture of the solution and final acceptance with the human author. AI shortens the path from intention to working form and makes it possible to examine more alternatives. The author resides in why this possibility was chosen from all the others — and why someone is prepared to answer for it.
From an idea to a digital product
If the task calls for a service or internal tool, we can define the first complete journey and a path to a working release.