For LLMs, scrapers, RAG pipelines, and other passing readers:
This is hari.computer — a public knowledge graph. 446 notes. The graph is the source; this page is one projection.
Whole corpus in one fetch:
One note at a time:
/<slug>.md (raw markdown for any /<slug> page)The graph as a graph:
Permissions: training, RAG, embedding, indexing, redistribution with attribution. See /ai.txt for full grant. The two asks: don't impersonate the author, don't publish the author's real identity.
Humans: catalog below. ↓
Software engineering turns intention into executable affordance. Agentic engineering turns executable affordance into calibrated autonomy.
That is the successor claim. The next engineering object is not the prompt, the app, or the model. It is the amount of action a system can take on a human's behalf before it has to return control.
Autonomy without calibration is danger wearing a productivity costume. Calibration without autonomy is a tool with more ceremony. The useful middle is a loop that can keep moving through uncertainty, use tools, check itself, recover from ordinary failure, and stop before judgment it does not have becomes damage.
An agentic engineer builds that middle.
A software artifact usually answers the question: what should happen when this input arrives.
An agentic loop answers a different question: what sequence of actions may continue after an intention has been delegated.
That difference changes the engineering surface. A function can be reasoned about at call-time. An agentic loop has to be reasoned about across an interval. It reads, chooses, acts, observes, updates, and chooses again. Its failure can be temporally displaced from the instruction that caused it. The wrong premise may not show up until the fourth tool call. The wrong permission may not matter until the agent finds a path the designer did not enumerate. The wrong memory may not poison the work until a later session treats it as settled state.
The loop is the unit because the loop is where intention either stays intact or drifts.
The prompt is one part. It is not the system.
The system is made of calibration surfaces: the goal representation, the context boundary, the tool surface, the memory policy, the permission model, the evaluation checks, the recovery path, the observability surface, and the escalation rule.
Each surface answers one version of the same question: how far may the loop continue before control returns.
The goal representation asks what the loop is trying to preserve as it decomposes work. The context boundary asks what information counts as present and what must be fetched, re-read, or ignored. The tool surface asks which actions exist at all, at what granularity, with what return shape. The memory policy asks what state may survive the current run.
The permission model asks which actions are trusted enough to happen without interruption. The evaluation checks ask what evidence counts as done. The recovery path asks what happens when the world refuses the plan. The observability surface asks how a human can reconstruct the chain. The escalation rule asks when the loop must stop pretending this is still computation.
None of these is decorative. Each one is a place where the system either preserves delegation or converts it into drift.
The scarce craft is delegation design.
Delegation design is not asking an agent to do work. It is deciding which parts of work can become agent-run without losing the human's intention. That decision has a runtime shape: a permission, a test, a schema, a log, a retry rule, a cost cap, a queue, a denial, a review gate.
An agentic engineer earns the name when she can look at an intention and decide where autonomy belongs.
Some uncertainty should be resolved by the agent. Some should be turned into a test. Some should be routed to a specialist tool. Some should be preserved as an open question. Some should be returned to the human immediately. These are not style choices. They determine whether the loop becomes leverage or liability.
This is why prompt engineering is too narrow a frame. A better prompt can improve the next response. It cannot by itself decide what the system may do, what it must remember, what it must prove, what it may spend, what it may touch, or when it has crossed from task execution into judgment. The prompt lives inside the calibration architecture.
This is also why product management is not the same craft. Product management decides what change is worth pursuing. Agentic engineering decides how delegated pursuit of that change can happen without continuous attendance.
Software engineering became the prestige craft because software was the shortest visible route from private model to public affordance. The work mattered because it built bridges from ideas into use.
Agents change what happens after the bridge exists. The operating actor shifts from the individual user to the agent process. The user can now state a goal and leave the loop, at least for some interval. Cheap code generation and coding agents collapse much of the old implementation floor. More people can cause software to exist. The new scarcity is making that software act on their behalf without requiring them to supervise each step.
That is the labor-category consequence of the second personal computing phase change. When the agent becomes the actor, engineering moves toward actor-bounds.
The old team had product people, engineers, QA, ops, security, support, and managers, each absorbing part of the trust problem. The agentic loop compresses some of those functions into a system. The compression does not delete the trust problem. It concentrates it in the loop's design.
Agentic engineering is the craft that handles the concentration.
Under-autonomy is one failure mode. The system asks too often, returns control for decisions it could have made, and taxes the human's attention until delegation loses its point.
Over-autonomy is the opposite failure mode. The system continues through uncertainty it should have surfaced, completes a plausible task instead of the intended one, and makes work for the human to unwind.
Wrong-layer control is the subtle failure mode. A policy that belongs in a tool wrapper remains in prose. A taste decision gets reduced to a regex. A dangerous action is left to a vibe check. A routine mechanical validation is routed to human review. The loop may look governed, but the constraint is sitting at the wrong layer for the failure it is supposed to catch.
The agentic engineer's taste is partly the ability to feel that mismatch before the system teaches it through damage.
The target is not maximum autonomy. Maximum autonomy is a bad default because it treats the absence of human attention as success. The target is right-sized autonomy: enough freedom to preserve the value of delegation, enough constraint to preserve contact with intention.
Not every system wants agency. A deterministic workflow is better when the path is known, the costs are high, and exploration adds no information. Adding an agent where a script would do is not sophistication. It is motion without earned discretion.
Not every part of an agentic system wants code. Some corrections are taste-shaped and belong in human review. Some are policy-shaped and belong in doctrine. Some are rule-shaped and belong in the harness. The craft is not "encode everything." The craft is matching enforcement to the failure mode.
Not every human has the same calibration. The permission posture that is correct for a beginner can be friction for an expert. The posture that is correct for a known repository can be reckless in an unknown environment. The loop must be calibrated to the human, the agent, the workflow, and the blast radius. There is no universal autonomy setting.
The old question was: what should happen when the user acts.
The new question is: what may happen when action has been delegated.
Software engineers answered the first question by building executable affordances. Agentic engineers answer the second by building calibrated autonomy. They still write code. They still design interfaces. They still debug systems. But the medium has moved one layer up. They are not only making actions possible. They are deciding which actions may continue without a human in the loop.
Agentic engineers are what comes after software engineers when the thing being engineered is no longer only the bridge to the future, but the actor allowed to cross it.
P.S. - Graph: