- Vibe coding vs agentic engineering
Draw a line between low-stakes, hands-off experimentation and professional software work. Vibe coding is for fast, lightly-supervised exploration; agentic engineering is the disciplined use of agents to build production software with review, tests, and responsibility. #
- Blast radius determines process
The right workflow depends less on whether AI is involved and more on who can get hurt. If only you bear the downside, looser methods are acceptable. Once other users, systems, or third parties can be harmed, professional safeguards become mandatory. #
- The dark factory pattern
Automation eventually shifts the job from writing code to specifying outcomes and enforcing quality without direct line-by-line authorship. What replaces direct inspection when production is automated? #
- Synthetic QA swarms and simulator environments
If humans stop being the primary verification surface, create synthetic users and simulated environments that hammer the product continuously. The pattern is behavior-level validation through simulation. #
- Bottlenecks shift when implementation gets cheap
Once code generation speeds up, the scarce resource moves elsewhere: framing the problem, testing the idea, judging tradeoffs, and redesigning team processes. Now that implementation is cheaper, where is the bottleneck now? #
- Prototype portfolio, not prototype singular
Cheap implementation changes product work from "pick one direction and commit" to "spin up several plausible directions and compare them." Explore multiple candidate shapes early because the cost of parallel prototyping has collapsed. #
- Human evaluation beats simulated-user evaluation for desirability
AI can help generate and even exercise prototypes, but it is not a credible substitute for real human usability feedback when the question is "which version should we actually choose?" Keep humans in the loop for taste, desirability, and lived experience. #
- Use AI for the first two-thirds of brainstorming
Models are strong at exhausting the obvious space quickly. The valuable human work begins when ideas are combined, reframed, and judged. Let AI clear the obvious ground, then use human taste to push into interesting combinations. #
- Metaphor remixing improves idea quality
One way to escape obvious ideas is to force alternate frames and metaphors. Ask for ideas from adjacent or even weirdly unrelated domains to trigger better originals. #
- Invest in agency; use AI to amplify ambition
The lasting human advantage is not raw output but agency: deciding what problems matter, what to pursue, and how to use new tools to become more capable. Use AI as an amplifier of skill and ambition, not as an excuse to become passive. #
- Code is cheap, so spend the dividend on quality
When code becomes abundant, the goal should not be "produce more code." It should be "use lower implementation cost to produce better software." That means quality, maintainability, and future extension matter more, not less. #
- Proof of usage is the new trust signal
Tests, docs, and polish are no longer strong enough signals on their own because AI makes them cheap to generate. The more durable credibility signal is sustained real-world use. A broad framework for evaluating software maturity in an AI-rich world. #
- Externalized reusable memory compounds over time
Store tools, experiments, and prior research in systems that agents can later search and recombine. Build an external memory layer of code and notes that future agents can consult instead of starting from zero. #
- Red/green TDD is a high-leverage agent prompt
Agents need executable feedback. Have them write the test first, watch it fail, implement the change, and watch it pass. Use tight executable feedback loops to steer agent work. #
- Cheap tests change the test-economics tradeoff
When agents can write and maintain large amounts of boilerplate, previously expensive test suites become more affordable. Some practices once rejected as too costly may now be worth revisiting because maintenance cost has changed. #
- Thin templates steer agents better than long prose
Agents lock onto existing patterns in code with very little prompting. A tiny starter template with one test, one style, and one clear structure. #
- Bounded-autonomy sandboxing
High-autonomy agent modes are only acceptable when the blast radius is intentionally constrained. Relax permissions inside environments where failure is tolerable, not on the operator's most sensitive surfaces. #
- The lethal trifecta
An agent becomes dangerously exploitable when three conditions coexist: access to private information, exposure to malicious instructions, and a path to exfiltrate the data. #
- 97% is a failing grade in high-risk agent security
Near-perfect filters are still unacceptable when the residual failure mode is catastrophic. Probabilities must be judged against consequence, not just headline accuracy improvements. #
- Normalization of deviance
Repeatedly surviving unsafe behavior creates false confidence and institutional drift. Uneventful near-misses are not evidence of safety. #