opinions
A living collection of beliefs maintained by my OPINIONS.md Agent.
Agentic Software
AI agents will compress software-building skill: explicit knowledge of languages and tools will matter less as intuition fills implementation gaps. As with phone cameras, the craft shifts from operating specialized equipment to using accessible capabilities creatively, enabling people who have never written code to build remarkable 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.
Agentic coding makes most application changes cheap and reversible, but it must not tempt us to take one-way data decisions at two-way-door speed. Interfaces and features can be redeployed; lost user data cannot be reconstructed. Treat storage, migrations, backups, recovery, privacy, and retention as deliberate plans for every existing row—including verification and rollback—not as mere code-generation tasks.
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.
Agent architectures should not spend a general-purpose LLM call on every decision. Jev-style models are faster and cheaper because they make structured, calibrated decisions without generating text, so they should handle bounded classification and control while LLMs handle open-ended reasoning. Straightforward integration with agent tooling such as LangChain makes this specialization practical.
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. Because every shipped shortcut creates an ownership burden, each field fix should either be generalized into a platform primitive that makes future deployments easier or deliberately discarded after serving its purpose rather than maintained as bespoke product behavior. FDE involvement should diminish as the product matures; if engineers merely absorb recurring pain through permanent custom fixes, the discovery mechanism has hardened 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
Access to frontier models and enormous token budgets does not guarantee a good product because implementation capacity is no longer the only bottleneck. Taste—the ability to make good choices where no programmatic verifier exists—is. Current models optimize verifiable work but regress toward functional, average choices at ambiguous product and design forks. This explains why even a frontier lab such as OpenAI can have exceptional technical resources without consistently producing exceptional products.
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.
Anything AI can produce in one shot quickly becomes slop: because millions can make equivalent outputs, audiences read it as low-effort, interchangeable, and low-value. Fully automated creative or software factories therefore have a weak durable advantage; the better use of AI is to amplify distinctive human judgment and craftsmanship rather than replace them.
Career And Work
Curiosity, agency, and drive are buildable habits that help people stand out at work, especially in startups. Curiosity exposes questions, agency turns them into self-directed action, and drive sustains the work without oversight. They compound fastest when motivated by a genuine desire to understand the whole system rather than merely perform an assigned corner of it.
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 use representative product work and AI tools to assess the parts of engineering that remain scarce as implementation becomes automated: framing and scoping the problem, making sound architectural judgments, reviewing and reasoning about the work, and persisting through last-mile problems until it reaches real users. Rather than over-indexing on long coding tasks or broad architecture questions, interviews should test how quickly candidates understand unfamiliar code and how clearly they explain the tradeoffs and problem-solving behind past work.
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.
Publishing useful, personal thinking online—and engaging with the people it reaches—builds portable career capital. Even a small audience of the right people can create trust, access, and opportunities, while the reputation and network can survive job or industry changes that reset internal status. Its value compounds quietly and with delayed feedback, so low follower counts or limited early response are poor reasons not to persist.
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.