The Workbench I Carry

Steve Jobs’s father Paul was a machinist and a carpenter. Paul taught his son that the underside of a cabinet deserves as much care as the finish, and the brake pads on a Chevy Impala deserve as much care as the paint job.¹ The standard had nothing to do with what the customer would see. The standard lived in whether the maker was willing to cut a corner when nobody was watching.

Steve’s deepest lesson was not taste as surface. It was integrity across the whole object. Every principle he carried into Apple followed from the first one Paul gave him: the invisible parts are where the standard proves itself real. The rest of this post is about how that principle lives in the AI systems I run today, one operative mechanism at a time.

TL;DR

Steve Jobs operated on five principles I can name: whole-widget integrity, care at every zoom level, refusal as product, simplicity as sophistication, and point of view visible at any surface. Each principle has a concrete manifestation in the Claude Code harness I operate and in the Hermes Agent project I contribute to. I do not run these systems out of fandom. I run them because the philosophy is the only way I know to build software that I would still respect in six months.

Recognizing The Standard

I recognized Steve’s standard before I ever read about Paul Jobs. My grandfather had a workbench in his garage, bathed in the light of a single bulb. He cut wooden motorcycles for me out of scrap, using washers for wheels and bolts for axles. I was five. The toy came from nothing. Joy came with it. My grandfather already understood what Paul understood: the material is not the product. The care is the product.

My dad taught me the same thing with soft-close drawer guides.² A cheap cabinet has a slamming drawer; a good one eases itself shut because someone engineered a mechanism into the rail nobody will ever photograph. The mechanism protects the visible front face for a thousand open-close cycles. Nobody sees the guide. The drawer stays tight because of the guide. I wrote about the full lineage in Why My AI Agent Has a Quality Philosophy; this post carries the same image forward into the Steve side of my doctrine.

Three households, one doctrine. When I encountered Apple in 2010, I was not converting to a new philosophy. I was recognizing one I already respected, rendered at a scale my family never could have reached.

At Apple, The Standard Had Scale

I arrived at Apple as a contractor through Trailer Park. The year was 2010. For the next two years, I made fixed-layout EPUB books for the iBookstore.³ Ansel Adams photography collections. Marvel comics. Shakespeare plays set with typographic care I had not seen in trade publishing. Children’s books with tap targets sized for small fingers.

Fixed-layout EPUB taught discipline. The format does not reflow. The designer composes every spread once and has to compose it right. Every tap target has to hit its coordinate. Every line break has to land where the designer chose, because the reader will see exactly the page the designer set. The format gives you no dynamic-layout escape hatch. You either place the pixel correctly or the reader notices.

Walking onto the Apple campus, I felt recognition, not awe. Someone had kerned the stairwell signage correctly. Someone had sweated the door hinge I touched on the way to get my badge. Someone had chosen cafeteria trays that spoke the same material language as the cafeteria chairs. I recognized what I was seeing. The standard my grandfather held in a single garage was the standard Apple held across a campus. Only the scope had changed.

October 5, 2011

I was on the Apple contract the day Steve died. I was close enough to feel the company’s silence, not close enough to claim ownership of it. My boss and I saw each other, understood what had happened, and teared up.

Why The Keynotes Still Matter

I still watch every Apple keynote. Not as fandom. As a calibration ritual. Once a quarter, for an hour, I sit with the question the keynotes ask out loud: who is still holding the standard, and where has the industry drifted?

The keynote is not the product announcement. The keynote is the industry check. If Apple shows a feature that would not have shipped in 2011, I notice. If Apple cuts a product rather than ship a weak one, I notice. The drift between a company that ships at the bar and a company that ships because the calendar says ship is visible in 60 minutes, four times a year. An hour is cheap for that clarity.

Steve Jobs’s Product Philosophy, Stated Directly

Five principles. Each one has a source in something Jobs said or did; each one has a manifestation in how I build.

Whole-widget integrity. Own the entire experience. Hardware, software, packaging, support, documentation, onboarding, the twenty-ninth email the user receives from you in year two. No component is outside the product. Jobs never shipped a Mac without the case; I never ship a skill without the hooks that shape its output.

Care at every zoom level, including invisible ones. Paul’s cabinet. The back of the fence. The hidden log file nobody will read unless something breaks. The commit message that nobody except future me will ever see. The standard either reaches those places or it does not reach anywhere.

Refusal as product. What you do not do defines you as much as what you do. The original iPod shipped without video; copy-paste took two years to arrive on the iPhone; the first iPad had no stylus on purpose.⁶ The refusal was the product move. A surface that cannot refuse has no taste; it has preferences.

Simplicity as the ultimate sophistication. The Apple II brochure headline.⁴ Simplicity is not fewer features; simplicity is the result of refusing to let complexity accumulate faster than the refusal to accept it. Every configuration option is a micro-failure of design.

Point of view visible at any surface. An Apple thing was recognizable as an Apple thing at any zoom level, from the box it shipped in to the weight of the charger. A product with no point of view is an average of its competitors. A product with a visible point of view is an opinion you can either accept or reject; either way, you know where you stand.

How The Philosophy Lives In My AI Harness

The above five principles are the shape of my AI harness. The harness is a configuration of Claude Code I have built over nine months, described at length in Claude Code as Infrastructure: 84 hooks, 48 skills, 19 agents, and roughly 15,000 lines of orchestration. Here is how the Steve side of the doctrine shows up in each layer.

Whole-widget integrity

The 84 hooks, 48 skills, and 19 agents are not a bag of tools. The harness produces one voice across every surface it touches. A code review from an agent reads like I wrote it. A commit message reads like I wrote it. A PR description, a deploy log, a blog post, a translation summary all carry the same micro-signature. Not because I write them all. Because the doctrine sits in the infrastructure, not in the prompt.

The SessionStart hook injects my active philosophies into every new session. The UserPromptSubmit hook attaches project context and date. PostToolUse validators enforce writing rules on every file I edit. The widget is the set of pieces that share an identity, enforced by infrastructure the model cannot skip. If one component degrades the whole, the whole is no longer a widget.

Care at every zoom level

Forty-nine of the 84 hooks are automations. Nobody ever reads them. They scrub credentials from commit diffs, validate deploy logs, lint frontmatter, sanitize file paths, catch TODO markers, rotate memory indices. The user sees a clean repository. The user never sees the rotation job that keeps the memory store lean. The back of the drawer at agent scale.

I measure care by the distance between the most visible surface and the least visible one. If polish stops at the visible surface while the invisible layer breaks, the standard is not real. If both surfaces hold, the standard is real. The harness enforces the second condition because 49 hooks keep the invisible surfaces honest.

Refusal as product

Thirty-five of the 84 hooks are judgment gates. They block actions on my behalf. They refuse to let the model commit credentials to bash. They refuse destructive git operations without explicit opt-in. They refuse writes to protected files. They refuse to allow a commit message that contains a TODO. Each refusal is a product move, not a safety feature.

The three-rebuild cap from Minimum Worthy Product is the refusal at the meta level. Three honest attempts, then escalate. The cap refuses both weak work and endless polish. The MWP essay is the shipping-standard case for the same principle Steve applied to the Lisa’s expansion slots, the original iPod’s scroll wheel, and the iPhone’s stylus decision.

Hermes Agent, the project I contribute to on the messaging side, operationalizes refusal through credential pools with explicit denylists and through skills that define what they will not do. My blog-writer-core skill carries a banned-vocabulary list of 23 words. My jiro skill defines seven named failure modes the machine cannot exhibit in a completion report. Each list is a refusal made into a first-class object, not a rule I hope the model remembers.

Simplicity as the ultimate sophistication

The hook dispatcher pattern is the simplicity move. Early versions of the harness had seven independent hooks firing on UserPromptSubmit, each reading stdin, two writing to the same state file. Concurrent writes truncated the JSON. Every downstream hook that parsed the file broke. The fix was a single dispatcher per event, running hooks sequentially from cached stdin. Seven problems collapsed into one mechanism.

In Hermes, the same principle lives in SOUL.md.⁵ SOUL.md occupies slot one in the system prompt and replaces the hardcoded default identity. One file, one identity, the agent’s personality across every messaging platform. Before SOUL.md, identity drift across long conversations was a constant problem. After SOUL.md, a single file governs who the agent is. The Hermes Tool Gateway is another simplicity move: one subscription, one config, one set of tools routed consistently across web search, image generation, text-to-speech, and browser automation. Not a collection of API integrations; one surface.

Point of view visible at any surface

SessionStart injects philosophy files before any prompt runs, so the agent’s point of view lives upstream of the user’s question. blog-writer-core enforces vocabulary and structural rules on every blog post, so every post I ship carries the same voice. Commit messages follow Conventional Commits. PR descriptions follow a template the harness enforces. Deploy logs follow a pattern. A reader could pick up any artifact my systems produced and identify the author from the shape alone.

Hermes carries the same move across 16 messaging platforms. SOUL.md re-injects at cadence so the identity does not drift over long conversations. The agent cannot assert a point of view once at the top of the session and keep it forever. The system has to reintroduce point of view continuously, because entropy toward generic assistant-speak is real and constant. Steve solved the same problem with keynotes: a company has to restate its point of view publicly, on a schedule, or the market forgets what the product stands for.

When The Standard Misfires

The philosophy is not an argument for cruelty, reality distortion, or control for its own sake. I am not inheriting Steve’s worst habits. I am inheriting his operating principles.

The operating principles have their own failure modes.

Whole-widget control hardens into tyranny when the harness refuses things I should have been able to ship. A protected-file hook once blocked me from editing a frontmatter field because the pattern matched too aggressively against a legitimate path. The hook was doing exactly what the rule told it to do. The rule was wrong for the case. Sometimes the hook is right and I am impatient. Sometimes the hook is wrong and I am right, and the discipline is knowing when to override the hook without lowering the bar.

Refusal calcifies into fear when a skill refuses every adjacent action instead of the specific action it exists to block. A banned-vocabulary list that grows every month eventually bans words the post actually needs. The remedy is the rebuild cap, turned inward: if the refusal has shrunk the scope three times, the refusal is the problem, not the scope.

Identity over-injection is the failure mode of SOUL.md. A soul file at slot one can swamp the user’s actual request. The agent declares too much and listens too little. The Steve version of the same failure shipped the original Macintosh underpowered because he held the closed-box architecture and the 128K memory cap against better engineering judgment; Sculley’s $2,495 launch price removed the affordability excuse the design had counted on.⁷ The Blake version ships a personal project too small because I held to a standard the market did not require.

Standards can harden into theater if they stop serving the product. The check is to ask, once in a while, whether the standard is making the thing better or making me feel more like Steve. If the answer is the second one, the standard has gone wrong.

FAQ: The Standard At Agent Scale

What is Steve Jobs’s philosophy of invisible craftsmanship?

Steve Jobs’s philosophy of invisible craftsmanship says the hidden parts prove whether the visible standard is real. Paul Jobs taught him that the cabinet underside and the brake pads deserve the same care as the finish. I apply that rule to software: hooks, logs, validators, and prompts are the underside of the product. If they degrade, the interface is only theater.

How does Steve Jobs’s philosophy apply to AI agents?

AI agents need standards embedded in their operating surface because they do not carry pride, memory, or taste reliably. My AI harness turns the Jobs philosophy into mechanisms: 84 hooks, 48 skills, 19 agents, and 15,000 lines of orchestration. The point is not to make the machine admire Apple. The point is to make invisible quality harder to skip.

What is whole-widget integrity in a Claude Code harness?

Whole-widget integrity means the harness behaves like one product, not a pile of prompts. A code review, commit message, PR description, deploy log, and blog draft should all carry the same standard. In Claude Code, that requires infrastructure: session context, post-edit validators, protected-file rules, and skills that define what the model should refuse.

Why does refusal matter in product design and AI systems?

Refusal is where taste becomes operational. A product says what it is by what it will not ship. An AI system does the same when it blocks credentials in shell commands, rejects destructive git operations, caps rebuilds, or refuses banned writing patterns. Without refusal, the system has preferences, not a point of view.

Close

Apple made the standard visible at scale. The harness carries the standard into a different medium. Software agents are not wood, steel, or glass; the lesson survives the material. Care at every zoom level applies to a hook the same way it applies to a drawer guide. Refusal applies to a skill the same way it applies to a product spec. Whole-widget integrity applies to a 15,000-line orchestration layer the same way it applied to the box the first iPhone shipped in.

Steve did not give me the standard. He proved that a private standard could become a public operating system. The workbench got smaller. The standard did not.

References