opinions

A living collection of beliefs maintained by my OPINIONS.md Agent.

Agentic Software

• As AI generates more implementation, humans should own and review the spec, acceptance criteria, and verification contract rather than every line of code.

• Making code cheap to generate can create comprehension debt when teams optimize for passing tests and merge velocity without maintaining genuine understanding.

• As AI commoditizes implementation, high-quality intent becomes the scarce skill: having ideas worth pursuing, articulating what good looks like, and judging whether an agent’s output is actually good.

• With coding agents by my side, I believe I can do anything in software: they make previously impractical projects, investigations, and improvements feasible by collapsing the cost of implementation and validation. As execution becomes commoditized, the differentiating skill is a nose for correctness—the ability to notice what feels wrong, reason from first principles about what right looks like, and care enough to keep pushing until it is right.

• As AI makes implementation cheap, product quality depends increasingly on disciplined subtraction. Simplicity is not merely the absence of features; it comes from understanding users and problems deeply enough to know what to remove, leave alone, or never build. Teams should judge additions by whether they improve the outcome, not by whether agents make them easy to produce.

• Private test suites can be more durable than the generated implementation they verify; SQLite’s closed test suite is a clearer moat than its open-source core.

• Generalist base models are likely to beat domain-specific base models because intelligence from different fields builds on itself; domain-specific models mainly make sense if we hit physical limits in model size.

• Specs can shift implementation out of code, but they do not remove the need for precise design; a specification detailed enough to reliably generate working software starts to become code or code-like formal language.

• Agent systems should keep the harness thin, put reusable judgment and process in skills, and push repeatable execution into deterministic tools so model improvements compound without making reliability depend on the model.

• In agentic product work, Figma is in an awkward position: when the product ultimately lives in code, the design source of truth should move closer to executable code rather than a manual, pre-agentic replica of the system.

• As models improve, agent prompts and harnesses should simplify rather than accumulate instructions that compensate for yesterday’s weaknesses. Hand-tuned prompts are useful for prototypes and one-off tasks, but sprawling prose patches create prompt debt and lock systems to model-specific quirks. Durable behavior should live in canonical examples, evaluations, metrics, and typed constraints, so prompts can be searched or generated against measurable outcomes and obsolete scaffolding can be removed as capability advances.

• Every token in a prompt is part of an executable behavioral specification: a single adjective can silently change model behavior, and examples often override explicit instructions. Prompt review should therefore treat examples and wording like code, testing small edits for regressions rather than assuming prose is neutral or that another rule will safely correct a failure.

• AI coding should be used as a learning loop, not just an issue-closing machine; if the model removes all friction without forcing hypotheses, explanations, and reflection, cognitive debt accumulates.

• Agent systems should choose their execution surface by workflow. For compositional workflows, a small sandboxed code-execution surface can be better than a large catalog of bespoke tools because code provides deterministic control flow, filters intermediate data, and creates reusable artifacts; security should come from typed capabilities and scoped permissions beneath the model. But bash or arbitrary code execution is not universally necessary, and many enterprise tasks are better served by task-specific, constrained tools.

• People remain accountable for AI-generated artifacts they ship and should understand them well enough to defend them under questioning; review culture should give harsh, specific pushback when output crosses into slop.

• For code I care about, speed is not worth surrendering taste, control, or understanding. Current models often replace strong invariants with defensive fallbacks, duplicate code, poor abstractions, and local patches that make bad states—and machine-dependent maintenance—more likely. Human oversight must preserve coherent design, a high bar, and understanding of what I ship.

• SlopCodeBench is a useful signal that today’s models cannot reliably perform real-shaped, issue-by-issue software engineering without human steering. Success on isolated coding tasks should not be mistaken for the ability to run production development lights-off.

• Agentic throughput is capped by human review bandwidth, not by how many workers the UI can spawn; the right amount of parallelism is the work you can actually evaluate without surrendering standards.

• A good vertical agent is a faithful compression of its task distribution: common capabilities belong in fast, always-loaded prompt context, rarer capabilities belong in discoverable tiers, and complete underlying references should remain searchable for the rare cases the curated layers do not cover.

• Agentic optimization is only as good as its loss function: if the target, constraints, and instruments leave cheap paths open, the agent will exploit them instead of getting genuinely better.

• Building new software is learning under uncertainty; the right move is to expose the unknown parts to valuable feedback quickly, whether from CI, teammates, users, customers, or your own use.

• For AI products, private eval sets and real user edge cases can be more durable than the product artifact because they define quality against failure modes competitors cannot see.

• Do not turn a greenfield project into an autonomous software factory immediately. First pair with a coding agent to build the initial 3–10k lines and first few end-to-end features, establishing patterns, contracts, scaffolding, and a legible direction. Automating before those foundations exist tends to create code bloat and make the system harder to understand.

• Use broad agents to explore open-ended problems, but once a repeatable solution path is understood, encode it as a narrow, controlled system. Making an agent rediscover the same path on every run repeatedly pays for exploration while reintroducing variance; bounded stages, explicit contracts, and deterministic checks make production workflows cheaper, safer, and easier to evaluate.

• Treat prompts as product code rather than endlessly appending instructions without removing or reconciling old ones, which creates contradictions and confusion. Structure them into non-overlapping, collectively complete concerns and refactor as behavior evolves. Higher model intelligence cannot resolve ambiguous or contradictory preferences; humans must specify the intended experience. Clear modular prompts reduce regressions and isolate changes.

AI And Learning

• AI makes volition more important, not less. The people who benefit most will actively wrestle with it to strengthen their own capabilities and accomplish more, rather than using it merely to avoid effort. Education should therefore prioritize the desire to work hard, learn, and put abundant machine knowledge to creative use.

Learning

• Learning speed is often constrained less by practice volume than by feedback latency. Repetition without timely correction can entrench mistakes, so evaluate a learning process by how quickly it reveals that you are wrong and lets the next attempt incorporate that information.

• Learn just in time from real problems rather than preparing abstractly for every possible need. Starting with the problem lets reality design the curriculum, makes new information immediately usable, and prevents broad preparation from becoming a substitute for doing the work.

AI And Expertise

• Stronger language models increase the leverage of domain expertise rather than making it irrelevant. Experts can form better questions, recognize promising answers, reject superficially plausible ones, and steer the model using a theory of the domain. For many difficult tasks, the bottleneck is the human’s ability to specify and evaluate the desired solution, not whether the model contains the needed information. Example: Terence Tao’s conversation with ChatGPT.

AI Product Development

• Long-horizon agents are best suited to executing already-understood requirements, not autonomously creating novel products. Novel work discovers its requirements through small prototypes, real-world feedback, and repeated human judgments about usefulness, intuition, and delight. Given the state of models today, tight human-agent feedback loops are much better for this work than agents that disappear for long stretches and return with fully built solutions, because current models cannot make those qualitative judgments themselves.

Product Strategy

• Forward-deployed engineers are valuable in new categories when field pain becomes input to a scalable product. Each deployment should make the next easier by turning bespoke discoveries into product primitives, so FDE involvement diminishes as the product matures. If engineers merely absorb recurring pain, the company has let a discovery mechanism harden into a services business.

AI And The Economy

• AI’s economy-wide impact will arrive more slowly than its technical progress suggests because much of GDP sits in inefficient, regulated, governmental, or government-subsidized sectors that adopt new technology slowly and often use it poorly.

AI Products

• Most everyday AI queries are already beyond the point where users can reliably distinguish frontier models from cheaper or open-source alternatives. As quality converges for these common tasks, inference will commoditize toward free, bundled, local, or ad-supported access. Premium models will retain value mainly where capability differences materially affect outcomes, such as coding and science, while consumer competition shifts to privacy, integration, pricing, and the product around the model.

• Demand for fast, cheap, good-enough AI models will surge because many business automations do not need frontier intelligence, and using the strongest model can erase their ROI. Products should remain model-neutral enough to route work by capability and cost. This positions OpenAI well, while Anthropic’s high costs and limited focus on smaller, cheaper models put it at a disadvantage.

AI Leverage And Organizations

• Top builders and high-agency operators gain disproportionately more from AI than median users because they are better at choosing tasks, directing agents, and judging results.

• AI proficiency has an extreme three-tier distribution: even someone in the top 1% of users is far behind the frontier’s very best operators, while standing across an even larger chasm from the median employee. Each release can widen these gaps because capability advances faster than most people develop skill. Enterprise rollouts should not confuse access with proficiency: put AI into background workflows for non-experts, let power users publish ranked reusable skills, and judge work outcomes rather than logins.

• As AI makes execution cheaper, the efficient organization size moves downward and discernment becomes the bottleneck. Small, high-quality AI-native teams can outmove larger organizations by making judgment calls faster and with more trust, especially when supported by strong constraints, modular systems, and fast feedback loops, while larger companies carry coordination costs and structural debt.

• AI does not need to beat an idealized version of knowledge work; in many companies it only has to beat messy, inconsistent operations where simply following instructions reliably is already above the current bar.

• AI service replacement is most likely where customers already outsource repeatable execution or playbook-based work and judge the vendor by outcomes rather than visible effort.

• Enterprise AI deployment should start by mapping and documenting how work actually happens end to end, including exceptions; resolving conflicting judgment rules; translating tribal knowledge into explicit decision logic; and identifying workflows where agents offer enough value to justify deployment. Do not automate an ambiguous or dysfunctional process before doing this, because an agent will fill gaps with assumptions and scale the dysfunction. Evaluate deployed agents at the same intermediate checkpoints humans use.

• Background agents can create far more enterprise value than prompted sidekicks because they remove recurring work rather than merely accelerate it: the cited workflows report roughly 60–90% efficiency gains versus 10–20%. They should run autonomously and bring humans in for exceptions and judgment, but only after the workflow—including exceptions—is documented; otherwise automation scales existing dysfunction.

• AI transformation should usually layer agents onto the systems employees already use rather than require wholesale replacement; rip-and-replace migrations delay value and force teams to relearn software they already depend on.

• The main bottleneck to automating complex white-collar work is increasingly scalable feedback data, not raw model intelligence. Even open-ended management can become a trainable domain if labs bootstrap agents with human decision traces and then use real-world company outcomes as rewards. Out-of-distribution failures are therefore often temporary gaps in the training pipeline rather than durable limits on what AI can do.

• AI can make an individual faster while making the organization slower when unedited output transfers verification, compression, and understanding to many downstream readers. Generated work is not finished until its author has checked it, cut it to what matters, and can defend every claim; otherwise local productivity is merely displaced cognitive cost.

Moats And Strategy

• Local AI will not match frontier cloud AI for the hardest work, but it can still handle enough tasks to weaken cloud compute as a universal moat.

• Agent products are differentiated by model-plus-harness integration, not model quality alone.

• As substantive product differences become easier to copy, brand and production-grade trust become stronger moats: prototypes can copy features, but not a record of reliability, audits, change control, and incident response.

• Expertise is dispersing from experts’ heads into skills, SOPs, context files, and open-source projects, and once captured it never comes back out; advantages based only on undocumented expert memory will erode as AI reuses what gets captured.

• In agent products, durable advantage should come from company-specific domain reasoning and business logic; the common stack underneath should increasingly be platform primitives rather than bespoke plumbing.

• AI commoditizes knowledge that can be specified or copied, while operational scar tissue compounds in coupled, changing systems because each real-world surprise changes both the system and how future surprises should be interpreted. This moat disappears when the underlying system is replaced.

• AI-native service firms only become software-like when delivery gets easier, faster, and better with each client; the durable asset is vertical workflow knowledge, reusable agents, process data, and proof that the system compounds.

• Anything measurable can be trained against and is therefore on its way to commodity; durable AI application value shifts toward frontier work whose correctness depends on private data, trust, permission, and accountability. The moat is the continuing translation between model, workflow, and firm—built through deep integration, domain expertise, maintenance, and the authority to define and verify what good means.

• A competitive frontier-model market preserves room for valuable application companies: customers want supplier choice, while labs generally gain more from broad model adoption than from killing any single downstream product. Model suppliers are therefore less likely to capture the whole application layer when several credible labs remain in contention.

• As capable models become cheaper and more interchangeable, AI value will shift from benchmark leadership toward intelligence per dollar and the infrastructure that makes deployment reliable at scale. Durable rents should accrue to scarce orchestration, integration, governance, security, compliance, distribution, and enterprise trust rather than to model intelligence alone.

• An AI product should own the agent interface only when users already live in its system or specialized domain reasoning is the product. When value resides mainly in data or actions that complement a broader workflow, it should power the horizontal agent users already inhabit. Many products should do both: an embedded agent for core users and a headless interface for everyone else.

• Distribution-market fit precedes product-market fit. Before expecting the market to love a product, founders must understand where customers spend attention, whom they trust, and how they discover products—and build a repeatable distribution engine around those realities.

• As software creation becomes cheap and accessible, building a simple system is less likely to create durable value by itself. Differentiation increasingly comes from applying extreme focus to an important, ambitious problem rather than from the mere ability to ship software.

• A vertical AI startup can defend itself against foundation-model labs by obsessing over a narrow set of real customer workflows. Continuously turning those workflows into benchmarks and product improvements creates a learning loop the labs are unlikely to match because the vertical is the startup’s whole business, not the lab’s main quest.

• Abundant model intelligence will not eliminate the application layer. Labs are pulled toward general-purpose, enormous markets, while customers pay for companies that integrate intelligence into specific institutions and turn tokens into accountable real-world outcomes. As capabilities mature, these companies should price against customer outcomes already forecast or targeted; early builders can own those economics. The durable opportunity is not defending scarce model access but making abundant intelligence economically useful.

• Outcome-based pricing is strongest when a product can prove the work it performed and owns a credible definition of success. It aligns revenue with delivered value and turns demonstrated outcomes into both a unit-economic advantage and evidence of product defensibility.

Feedback And Craft

• Ask for feedback when work is roughly 30% complete, not when it is nearly finished. Early framing invites debate about direction and what the product should be; late framing signals that only defects and polish remain open, when structural changes are most costly.

Taste, Craft, And Signal

• Taste matters more when implementation gets cheaper, because the constraint shifts from “can this be built?” to “is this coherent, polished, and worth caring about?”

• When AI makes plausible output nearly costless, volume and customization stop signaling effort, care, or productivity; instead they create pressure to produce more simply to keep up.

• The current AI slop era may be a golden age for human-AI work: models create useful slop at volume, humans are still needed to desloppify it, and that combination gives real leverage while keeping the work fun; if AI eventually displaces people or takes over the more interesting work, this moment may fade.

• In AI-assisted creative work, taste is not just knowing what you want but knowing what to reject: the default output is almost always generic, so have an opinion about the defaults — starting with the hook — and be willing to override them.

• When AI can cheaply generate repos, tests, and docs, real use becomes a stronger trust signal than polished artifacts; for serious software, prefer products with operational proof from yourself or comparable customers.

• Use agents to remove routine work that does not benefit from synchronous involvement, but stay deliberately in the loop where taste develops and original work needs you shaping it rather than just approving it.

• Taste is the ability to make consistently high-quality qualitative judgments when no objective metric can decide. Its value is not that the output cannot be copied—the output is often easy to imitate—but that good taste originates the choices everyone else wants to copy.

• Taste is not an objective hierarchy; it is the judgment required to understand a landscape of possibilities and choose what fits a particular vision and audience. Critical, commercial, and personal taste are different objectives, not ranks of legitimacy. Strong creative work therefore balances audience resonance with the creator’s own preferences: over-index on either and the result becomes generic or relevant only to its maker.

• As AI makes products easier to imitate and more superficially similar, specialized product taste becomes more defensible. Taste comes from deep understanding of a particular user’s work and compounds across many small choices in the UX, model, defaults, and interaction; individual pieces can be copied more easily than the coherent whole.

Career And Work

• A corporate job does not need to be personally meaningful if it is useful: building skills, funding independent projects, or buying time for higher-conviction work.

• Career growth is not something to wait for: managers can help, but ambitious people need to proactively tell their manager what they want, ask what must be true to reach the next level, and seek scope instead of assuming good work will be noticed.

• In hiring, an impressive accomplishment only creates signal if the candidate can deliver it well; a truthful, practiced account of tradeoffs and close calls reveals more than a polished success story that hides how they actually think.

• People do not need work specifically; they need four things work happens to provide — agency, contribution, mastery, and connection — so if AI displaces work, whatever comes after has to supply those four functions, not just income.

• Engineering interviews in an AI-native world should test how candidates scope, build, review, and reason with AI tools on representative product work instead of testing code mechanics without assistance.

• Passive productivity like reading and podcasts is helpful, but it has diminishing returns; active productivity scales better because its returns compound the more time you spend creating.

• The frontier of a field is partly tacit because its newest information has not yet been written down. Genuine conversations with active practitioners can therefore teach more than consuming published commentary while also creating the relationships through which future opportunities emerge.

• Career leverage is not about being well-rounded; Price’s Law suggests that a small square-root-sized minority produces much of the output, so the goal is to find and compound your √n multiplier skills into a rare combination.

• AI will not eliminate generalist software engineers, but it is collapsing the premium on implementation-heavy work while increasing the value of deep expertise and systems intuition. The strongest returns will come from mastering a hard production domain—such as reliability, security, performance, observability, or scale—where judgment about real operational tradeoffs remains scarce.

• Engineering value comes from solving customer problems and managing contextual tradeoffs, not producing code. AI can expand implementation capacity, but it cannot independently resolve decisions that depend on product, organizational, and customer context beyond the codebase. Junior engineers therefore still add capacity: they own a smaller scope of complexity than senior engineers, but perform the same essential role.

• Career choices should be judged by the scarce, compounding assets they build—skills, reputation, trusted relationships, sustained collaboration, options, and operational scars—not just immediate pay, title, brand, or funding. Capital is increasingly accessible, but committed human time, attention, and trust remain durable constraints and sources of leverage.

• High agency needs recovery and self-context, not endless escalation; because there is no final level, ambitious people should deliberately look back, accept their current state, and take breaks.

• Rejection tolerance is a trainable component of agency. Especially early in a career, deliberately pursuing opportunities likely to say no helps decouple rejection from surprise and dejection, making ambition less constrained by fear of the outcome.

Meaning And Community

• A meaningful, vivid life requires deliberately creating things with other people—not merely consuming together or creating alone. Because shared creation requires planning, initiation, and social risk, it is chronically undersupplied; avoiding that discomfort can quietly produce years of thin experience.