Skip to content

Blog

Archive

Every post on the blog, newest first.

  1. Measuring AI impact on engineering: what to count and what to ignore Code volume, pull requests, usage: AI pushes up every number that is easy to count. A Stanford talk and DX data put the measured gain at around 10 percent, and it swings widely from company to company. What to measure instead, where the returns come from, and why things get worse before they get better. 13 min read Measuring AI impact
  2. Breaking the Loop: Why agents never finish on their own Agents in a software factory always find another problem, another ticket, another improvement. Only a second, much slower loop can say when the work is finished: the one that reaches the market. 22 min read Specification and review
  3. A hook is not a boundary: why agents need a sandbox A training group got an agent past a hook that guarded a secrets file. A hook filters the calls it was written for, a sandbox limits what the agent can reach, and the trade between the two is a company decision. 1 min readShort post Agent security and risk
  4. Agents finished the portal, then it waited in a queue An agent-built portal was ready to ship and waited on a gateway, a firewall rule, a certificate and QA. A factory shortens the build, and only a self-service platform shortens the wait around it. 1 min readShort post Organization and roles
  5. Fast agents push the bottleneck back to the requirements Delivery was built around slow coding. With code, review and deployment fast, questions return faster than anyone answers them, and the constraint moves to where requirements are written. 1 min readShort post Specification and review
  6. A swarm of subagents is not throughput Coordinators that fan out to thousands of subagents measure merged pull requests, which is output. The limit on fan-out is how much a team can check well enough that what lands is what customers need. 1 min readShort post Coding agent setup
  7. Engineers finally get to work on the system When an agent gets it wrong, the fix is a rule, a skill or a hook rather than an edit to the code, so the engineer's job moves from working inside the system to working on it. Engineers were rarely given that job and have few criteria for doing it well, so a team has to decide what the work is judged by. 1 min readShort post Adoption
  8. Who owns the file every agent reads first Since Claude Code 2.1.277 reads AGENTS.md where no CLAUDE.md exists, one instruction file can serve every coding agent on a team. The file was never the hard part: the instructions are a team decision and need one owner, so merge the files into one AGENTS.md and name who owns it. 1 min readShort post Context engineering
  9. Give every team one AI hypothesis instead of generic training Generic AI training across 300 people produces compliance, not adoption. One written hypothesis per team, tested on a retro cadence, makes the rollout correct itself. 1 min readShort post Adoption
  10. Architects already solved non-determinism with eventual consistency Architects reject AI-generated code because it is non-deterministic. They solved that exact problem a decade ago in their event-driven systems, and the saga pattern shows where the correctness comes from. 1 min readShort post Specification and review
  11. A label on an issue is the whole protocol between agents The development-workflow skill in the software-factory.dev factory is the factory's own map of itself. It shows that the automations never call each other: they coordinate through labels on issues. 2 min read Software Factory
  12. When agents write the code, judgment should outrank titles Career ladders reward scope because writing good code at volume used to be scarce. Agents moved the scarcity to judgment, and hiring, leveling, the ladder and pay all need to follow. 2 min readShort post Organization and roles
  13. Agent-paced merging turns the merge queue into a database problem The merge queue used to be a scheduling problem between people. With agents opening changes around the clock, it becomes concurrency and conflict resolution against shared state. 2 min readShort post Software Factory
  14. Report the daily delta, not the total that only goes up The Tweet Drafter in the software-factory.dev factory posts updates three times a day and reports the daily delta, not the cumulative total, because a total always looks like progress. 2 min read Measuring AI impact
  15. An agent is a loop, and the loop is what you debug A coding agent perceives, decides, acts and observes, then repeats. Naming which of the four steps failed turns a mystery into a fix. 2 min readShort post Coding agent setup
  16. Six developer experience investments that outlast the next model Most agentic tooling bought this year will not survive the next model generation. Six fundamentals will, because what is good for human developers turns out to be good for agents. 2 min readShort post Software Factory
  17. An automated status report is only as honest as its prompt The weekly recap automation in the software-factory.dev factory stays honest because the honesty is written into its prompt: the challenges section is what makes it authentic, and an unrecorded number has to be named as unrecorded. 2 min read Software Factory
  18. Double throughput needs a mandate, not another pilot A pilot asks a team to prove agentic engineering works here. A mandate states the outcome and makes the boring blockers somebody's problem, which puts the uncertainty on the organization. 2 min readShort post Organization and roles
  19. Million-token windows did not remove the dumb zone Agent quality degrades without warning above roughly 40 percent context fill, the zone Dex Horthy named. Windows grew to a million tokens and the failure mode came along, so starting bare metal is still the habit that keeps a session out of it. 2 min readShort post Context engineering
  20. A metric without a red line is decoration The weekly Performance Monitor in the software-factory.dev factory works because every metric it watches has a hard threshold written into it. 2 min read Measuring AI impact
  21. Feed the factory the decisions nobody wrote down In most organizations the knowledge that matters most is decided out loud in meetings and never written. Five concrete steps route it into the context layer the factory reads. 2 min readShort post Context engineering
  22. Find where the work piles up before you pick an AI playbook Four engineering organizations put AI on four different problems. What transfers from them is the diagnostic they all ran first: where does the work actually pile up? 2 min readShort post Adoption
  23. An automation that audits the factory must not rewrite its own record The automation auditor in the software-factory.dev factory inspects every other automation on the line. Its most useful rule: it may never overwrite last week's audit. 2 min read Software Factory
  24. Escalated work needs a return path back onto the line The smallest automation in the software-factory.dev factory puts escalated issues back on the line once a human has answered. The return path from human to machine needs its own owner. 2 min read Software Factory
  25. YAGNI still holds, for a different reason Cheap code tempts teams to generate the flexible version just in case. But writing was never the only cost. Reading, debugging, and changing the code still cost a human, and YAGNI now protects those. 2 min readShort post Specification and review
  26. AI tool fatigue is a missing context layer Teams count their AI tools when the list that decides is the second one: skills, commands, CLAUDE.md entries and context files. Where that list is rich, the tool list shrinks on its own. 1 min readShort post Context engineering
  27. Set the stale-work clock from your agents' cycle time The Stale-Issue Reviewer at software-factory.dev calls work stale after three hours, not three days, because a watcher's clock has to run at the speed of the line it watches. 2 min read Software Factory
  28. Run the migration you keep postponing as the training Train agentic engineering on the legacy migration the team has postponed for years, not on a sandbox. The team learns on its real codebase while the debt shrinks. 2 min readShort post Adoption
  29. In a regulated enterprise, the committee is the AI bottleneck Code generation is solved. In a regulated enterprise the constraint is the approval process, so the fastest path to adoption is one that needs no new tool approved. 1 min readShort post Agent security and risk
  30. The PR Shepherd resolves only the conflicts it understands The PR Shepherd in the software-factory.dev factory rebases conflicted pull requests but hands semantic conflicts to a human. The hard part of automation is encoding where its competence ends. 2 min read Software Factory
  31. When the CEO sits in the developer training AI stopped being a tooling purchase and became an investment in the environment: the harness, the context layer, the trained team, the hiring filter. A CEO doing the exercises next to their staff engineers shows the shift. 1 min readShort post Adoption
  32. Every automation needs a scoped, reversible sandbox Teams design what their automations do and neglect where they run. A written blast radius, a narrow scope and throwaway environments decide whether you can leave an automation unattended. 2 min readShort post Agent security and risk
  33. Verify UI components in the page they ship in The UI Verifier in the software-factory.dev factory screenshots every changed component twice, in isolation and in the real page, because a component that passes in isolation can still fail where it ships. 2 min read Specification and review
  34. Put your coding agents in the outer loop The inner loop is your IDE, the outer loop is CI, review automation and scheduled upkeep. Most teams put agents in the inner loop, but the work that compounds lives one loop out. 2 min readShort post Software Factory
  35. Agents stall on unclear requirements, and a spec file fixes it A pilot team blamed the agent until it looked at what the agent was handed. The fix was one spec file in the repo, with QA's test cases written before any code. 1 min readShort post Specification and review
  36. Coding agents are an organizational-design problem Cheaper local generation pushes the coding-agent constraint into team practice, the shared platform, governance, and learning. One practitioner's four-level model of that shift, held up against what DORA can and cannot support. 6 min read Organization and roles
  37. Why faster coding does not guarantee faster delivery Productivity research measures task time, perceived savings, pull requests, and production flow, each in its own way. Read side by side, the measures show where the constraint moves. 5 min read Measuring AI impact
  38. Software Factory evidence and its limits Public implementations show that agent-run delivery systems can build and ship software. Read their numbers with a source label, a scope, and careful limits. 3 min read Measuring AI impact
  39. Verification in a Software Factory When generating code gets cheap, a Factory's throughput depends on how well the system can establish that a change is acceptable, safe, and worth shipping. 3 min read Specification and review
  40. Green CI does not prove the live site works The Post-Merge Verifier in the software-factory.dev factory smoke-tests the real production site after every merge, because passing tests and a working site are two different claims. 2 min read Specification and review
  41. What is a Software Factory? A Software Factory coordinates agents, context, deterministic gates, and human decisions across the path from intent to production. 3 min read Software Factory
  42. Build an auditor that improves your automations' prompts An automation that rewrites other automations' instructions sounds risky. Built as a loop of real runs, explained verdicts and a reviewed diff, it is continuous improvement with one gate. 2 min readShort post Software Factory
  43. When engineering speeds up, the bottleneck moves to product A workshop mapped a full SDLC against agents. Almost every step compressed, except deciding what to build next, and most organizations are not staffed for that shift. 1 min readShort post Organization and roles
  44. An auto-merging PR reviewer is safe once it knows when to stop The PR Reviewer in the software-factory.dev factory merges code with no human approval. One number makes that safe: it gives up after three failed attempts to fix CI. 2 min read Specification and review
  45. An autonomous agent has to verify its own work Agent-built features can look finished and be broken. The user will not check, so the agent has to, and that changes how you build one. 2 min readShort post Specification and review
  46. Your org chart is the context architecture An agent asking a question routes through the same knowledge layers a new hire would. Federated context follows the org chart, with a neutral mediator for the deadlocks. 2 min readShort post Organization and roles
  47. Daily metrics that cannot drift: subtract yesterday's total The Daily Metrics automation in the software-factory.dev factory never measures a daily change with a date-filtered query. It subtracts yesterday's cumulative total from today's, a method that cannot drift. 2 min read Measuring AI impact
  48. Your coding agent is a free audit of your documentation Code generation is solved, so the constraint is now context. Every wrong answer an agent gives points at a standard the team knows and never wrote down. 2 min readShort post Context engineering
  49. Agentic coaching is the new agile coaching Adopting agentic engineering has the same shape as adopting agile twenty years ago: an organizational change, resistance among senior people, and the same three levers that worked the first time. 2 min readShort post Adoption
  50. A bug-fix automation must never exit quietly The bug-fix automation in the software-factory.dev factory has two ways to end a run: it ships a fix or escalates to a human. Honest failure is a feature you have to design. 2 min read Software Factory
  51. Skills hold what agents need to know, sub-agents do the thinking The first architecture decision in an agent setup is sorting what needs to think from what just needs to know. Skills carry static knowledge, sub-agents do dynamic work, and the split decides the cost. 2 min readShort post Coding agent setup
  52. Refinement, not coding, was the bottleneck all along Several teams turned the same rough story into wildly different plans. The agent did not create the ambiguity. It showed that deciding what the work means was always the slow step. 2 min readShort post Specification and review
  53. The Feature Builder checks for open bugs before it builds The software-factory.dev build automation runs a pre-flight check first: a priority-1 or priority-2 bug nobody has picked up stops all new feature work. 2 min read Software Factory
  54. Agentic adoption is harder than agile, because you can't fake it Agile rollouts could rename roles and keep the waterfall. Agentic engineering returns nothing on half-measures, because every gate sits upstream in architecture, context and the team. 2 min readShort post Adoption
  55. Context engineering is the standardization you could never sell Preparing context for AI agents forces the documentation and standardization architecture teams have pushed for years. The agent does not need it more than the organization did. It removes the resistance. 1 min readShort post Context engineering
  56. An improvement automation needs a cap on its ambition The Product Improver in the software-factory.dev factory files at most three issues a run, and zero when it finds nothing worthwhile. 2 min read Software Factory
  57. A harness is a list of things the model cannot do yet A harness is not plumbing around a model. Every component in it encodes one assumption: a thing the model cannot be trusted to do alone. Read it that way and the harness becomes a checklist. 2 min readShort post Coding agent setup
  58. 1,300 agent PRs a week rest on three million tests Stripe's 1,300 unattended pull requests a week get quoted everywhere. What makes them work is the test layer and the harness underneath the agents. 2 min readShort post Specification and review
  59. Fix the incident and the rule in the same commit The Incident Responder in the software-factory.dev factory updates the conventions document in the same commit as the fix, so the rule that would have prevented the bug is there before the next change. 2 min read Software Factory
  60. When the factory dispatches the work, the manager runs the line When the factory handles assignment and status, the engineering manager's job moves from dispatcher to line operator. Five responsibilities now define the role. 2 min readShort post Organization and roles
  61. When code is cheap, agreeing on what to build is the bottleneck Slow typing used to force teams to agree before they built. With agents, a vague ticket produces two confident builds, so the fix moves upstream into a short alignment doc. 2 min readShort post Specification and review
  62. Cross user feedback against usage before it becomes work The Feedback Digest in the software-factory.dev factory reads new feedback next to seven days of usage data, and files an issue only when the evidence backs it. 2 min read Software Factory
  63. Delegate, review, own: the operating model of AI-native teams A model lab's playbook for AI-native engineering teams repeats one pattern across seven SDLC phases. The hard part is the review, where the engineer decides which agent findings matter. 2 min readShort post Organization and roles
  64. When code is cheap, the design decision is the expensive part When a full feature costs a few dollars to generate, throwing code away stops being waste and becomes the cheapest way to test an idea. The constraint moves from writing the code to deciding what survives. 1 min readShort post Specification and review
  65. The Feature Planner writes its own backlog, behind a human gate The triage automation in the software-factory.dev factory also writes its own backlog when the line runs dry, and routes anything risky through a person first. 2 min read Software Factory
  66. Review the short alignment doc, not the thousand-line plan The team that popularized research, plan, implement published what they got wrong. Read the code, and put human attention on the short doc before the plan, where a bad assumption is still cheap to fix. 2 min readShort post Specification and review
  67. Moving faster with AI only happens when it is a goal A software factory gives you output speed. Outcome speed needs the organization to change around it, and a change that isn't a goal loses to every change that is. 2 min readShort post Organization and roles
  68. AI pays off in maintenance work, not in the demos DX Research ranked ten developer tasks by AI time savings. The tasks most rollouts start with, code explanation and scaffolding, sit at the bottom, and the gains land in brownfield work. 1 min readShort post Measuring AI impact
  69. Most AI rollouts change the codebase and leave the team untouched In a Multitudes survey, codebase changes made up 85% of what teams changed for AI, and only 13% named a process change. In our experience, that gap is why most rollouts hit the same wall. 1 min readShort post Adoption
  70. Agency, not the tool, decides whether AI works for a team Skill on one axis, agency on the other: four quadrants with four very different outcomes. Give senior developers agency and the tool starts working. Strip it away and even the best reject it. 2 min readShort post Adoption
  71. Boards want 10x, and most companies are not measuring The 10x number keeps showing up in board decks while few companies measure anything. The pressure rolls downhill, and the gap between what gets reported and what happens keeps widening. 2 min readShort post Measuring AI impact
  72. Teams that rebuilt their org chart got more out of AI McKinsey surveyed about 300 enterprises on AI adoption. Top performers were 7x likelier to run AI-native workflows, while 70 percent have not changed roles at all. Pod restructuring is an upstream investment. 2 min readShort post Organization and roles
  73. Clean codebases decide who gets value from AI Stanford research on 120,000 developers, presented in a talk, found codebase cleanliness predicted AI value better than token spend. Teams with weak codebases regress past a certain spend. 2 min readShort post Measuring AI impact
  74. The costly mistake is hovering over your agent Writing 20 lines by hand is no longer the overcorrection to worry about. Staying in the loop so tight that the agent never gets room to work costs far more. 1 min readShort post Specification and review
  75. Vouch for the harness, not for its output Code review cannot keep up with agent output. Open source maintainers already admit contributors instead of reviewing contributions, and in an agentic factory the contributor to admit is the harness. 1 min readShort post Agent security and risk
  76. Measure AI impact, not AI usage Most companies track how much their developers use AI tools. The DX AI Measurement Framework adds impact and cost, and the metrics that survive measure what reaches production. 2 min readShort post Measuring AI impact
  77. Agent teams win by moving complexity out of the agent Vercel, Manus and Pi got better results by removing tools from the agent. The orchestration belongs in deterministic factory steps around a small, focused agent. 1 min readShort post Coding agent setup
  78. AI adoption is a leadership problem Teams with every AI tool available still drop them within weeks. Three leadership responsibilities decide whether adoption sticks: unblock usage, make adoption visible, reduce fear. 1 min readShort post Organization and roles
  79. AI inflates the metrics that don't measure value AI pushes up every number that is easy to measure: code volume, pull requests, velocity. Four metrics show whether the value went up with them. 1 min readShort post Measuring AI impact
  80. AI velocity without engineering discipline fires slop A framework sorts tech roles into four archetypes, and it reads like a raid party. AI rollouts without engineering discipline add damage output with no tank and no healer. Agentic engineering balances the party. 2 min readShort post Specification and review
  81. One AGENTS.md for four AI tools is harness debt A single context file behaves differently in every harness and every model. The four kinds of harness debt we keep finding in teams, and what a Dark Factory does instead. 2 min readShort post Context engineering
  82. Strong automated gates separate a dark factory from a bullshit factory Above a certain complexity, human code review lowers quality at agent speed. Quality inversion, the automation ratchet, and what a software dark factory needs instead of approvals. 1 min readShort post Software Factory
  83. AI modernization works as a delivery problem, not a code translation Translating COBOL to Java one to one reproduces the old debt. Treated as delivery, with architecture decisions, encoded context and a migration factory, AI-driven modernization works. 2 min readShort post Software Factory
  84. Every company will build its own software factory The question shifts from which editor a team uses to what its factory looks like. Four stages lead from autocomplete to a factory that improves itself, and no team can buy its factory off the shelf. 2 min readShort post Software Factory
  85. AI makes teams faster and wears down their engineering instincts Agents speed up output while problem decomposition, debugging and code comprehension fade. The answer is to encode the team's engineering knowledge into a harness. 2 min readShort post Adoption
  86. Agent-written code breaks what code review was for Code review was never mainly about catching bugs. It kept the team's mental model aligned, and agent-written code breaks that loop before anyone has built the replacement. 2 min readShort post Specification and review
  87. AI writes your tests, but not the one for the right problem A suite at 94% coverage, every test green, for a feature no user completed. The test that checks the business need depends on context only humans can supply. 2 min readShort post Specification and review
  88. If agents can run a company, what is a company for? A panel on responsible agentic development ended on a question it could not answer: follow the efficiency logic all the way to zero employees, and what is left of a company? 2 min readShort post Organization and roles
  89. The agent shipped a story while the developer slept In a pilot, an agent implemented a complete user story overnight. When work no longer needs a person awake, sprint planning, team sizing and the developer's job have to be rethought. 2 min readShort post Software Factory
  90. Morgan Stanley saved 280,000 hours by reading old code Most teams point AI at code generation. Morgan Stanley pointed it at code understanding, the step where developer time actually went. 2 min readShort post Measuring AI impact
  91. Cheap code makes engineering discipline worth more Generating code got cheap, and anyone can do it. Engineering systems that hold up in production is the skill that gained value. 1 min readShort post Specification and review
  92. Another company's AI success story won't transfer to yours DORA research shows AI returns vary widely between organizations using the same tools. The variance is the signal: measure your own baseline and your own bottlenecks before copying a playbook. 1 min readShort post Measuring AI impact
  93. A vibecoded SaaS leaked user data because nobody owned the design A production SaaS built by vibe coding failed in four different ways with one root cause. What survived shows why AI-generated code needs someone who owns the system design. 1 min readShort post Agent security and risk
  94. Compounding engineering makes each feature ease the next one Most teams use AI to code faster. Compounding engineering adds a fourth step, codify, so that every feature makes the next one easier to build. 2 min readShort post Software Factory
  95. A study says context files hurt agents. It tested the wrong thing ETH Zurich found that auto-generated context files make agents worse. That shows auto-generation is useless, not context files. A useful context file records where the model fails your project. 2 min readShort post Context engineering
  96. Context management matters more than picking the model Letting developers pick a model solves the wrong problem. The real constraint for coding agents is context, and AMP answers it with sub-agents, two working modes and fewer, sharper tools. 1 min readShort post Context engineering
  97. AI makes code easy, and only a spec keeps it simple Conversational coding piles every instruction onto the last until the code tangles. Rich Hickey's distinction between easy and simple explains why, and a research, plan, implement process is the fix. 2 min readShort post Specification and review
  98. Claude Code can now navigate your code like an IDE Claude Code used to search a codebase with grep and text matching. With Language Server Protocol plugins it gets real code intelligence: references, signatures and types. 1 min readShort post Coding agent setup
  99. What context engineering looks like in practice The gap between mediocre and strong agent output comes from how you instruct the agent, not from the model. Concrete practices across three layers: prompting, context and verification. 1 min readShort post Context engineering
  100. Research, plan, implement keeps coding agents out of the dumb zone A coding agent gets worse the longer a session runs. Research, plan and implement in separate, compacted steps, use sub-agents to control context, and put human effort where mistakes cost the most. 2 min readShort post Context engineering
  101. A good CLAUDE.md describes how to think, not the project The default CLAUDE.md lists the stack and the commands, and it shapes nothing. The useful ones set philosophy, rules, protocols and principles for how the agent works. 1 min readShort post Context engineering
  102. Working well with coding agents takes months, not hours Experienced engineers resist agentic coding, and most people quit after a couple of hours. The value only shows once you have put in the time to learn the new skills. 2 min readShort post Adoption
  103. The highest AI returns come from automation, not time savings Data from more than 2,500 self-reported use cases shows time savings as the most common goal and the most modest return. Risk reduction, agentic automation and broad adoption pay off more. 1 min readShort post Measuring AI impact
  104. The gap between AI-fast developers and AI-slow companies Individual developers report large gains with AI while whole companies report 5 to 15%. The gap is a management problem: companies added tools without reorganizing how they work. 1 min readShort post Organization and roles
  105. The best agent architecture is a simple while loop Claude Code and the pi agent show the same thing: a main loop, a few general-purpose tools and careful context management beat elaborate orchestration. 1 min readShort post Coding agent setup
  106. Run retrospectives for your agents, not just your team Teams run retros to improve how humans work, but agent mistakes die with the session. Saving sessions, letting a retro agent mine them and turning failures into config rules makes the learning compound. 2 min readShort post Software Factory
  107. Do the sprint planning work before the planning meeting Most of what a planning meeting answers needs data, not a meeting. Agents split stories, map dependencies, order tasks, write evil user stories and check acceptance criteria before anyone sits down. 3 min readShort post Specification and review
  108. Do the refinement research before the refinement meeting Refinement meetings exist to clarify requirements and surface blockers. An agent with codebase access does most of that research and questioning before the meeting, so the team only decides. 1 min readShort post Specification and review
  109. Agents should write code to call MCP tools, not call them directly In Anthropic's example, direct MCP tool calls took 150,000 tokens and an agent writing code to call the same tools took 2,000. Code execution is the way to use MCP. 2 min readShort post Coding agent setup
  110. AI helps teams build waste faster unless they fix the root causes Teams use the speed of AI agents to ship more features instead of better ones. Four problems teams claim to solve with AI are symptoms of root causes AI does not fix. 2 min readShort post Organization and roles
  111. AI makes a feature factory faster, not better Automating the system you already have makes teams more efficient at building things nobody needs. The difference lies in where you invest the time AI saves: validation or more features. 2 min readShort post Organization and roles
  112. Most agent failures are context problems, not prompt problems Prompt engineering is how you ask. Context engineering is what the model sees. Eight practices, the symptoms of a badly built context and a four-question audit for the window. 2 min readShort post Context engineering
  113. GenAI creates more work before it creates less A German study of IT leaders finds 73% still have the trough of the J-curve ahead of them. Its authors call the next 18 months decisive. 2 min readShort post Measuring AI impact
  114. For tools you own, build a CLI before an MCP server Every MCP server loads all its tools into context before the agent starts. Keep MCP for external services and give your own tools a CLI, scripts or skills, which cost a fraction of the context. 2 min readShort post Coding agent setup
  115. Slash commands, MCP, sub-agents and skills form a hierarchy Teams build the same workflow three ways because they treat Claude Code's four overlapping features as equals. They form layers: prompts at the base, MCP and sub-agents beside each other, skills composing the rest. 2 min readShort post Coding agent setup
  116. Shallow agents fail at step 20, deep agents plan and remember The prompt, tool, result loop works for 5 to 15 steps and collapses on real work. Deep agents add explicit planning, delegation to sub-agents, persistent memory and heavy context engineering. 2 min readShort post Coding agent setup
  117. One general agent with a skill library beats 47 custom agents Teams cram every procedure into monolithic agent prompts. Agent Skills replace them with one general agent and a composable library that loads knowledge in layers. 2 min readShort post Coding agent setup
  118. Agents fail from amnesia: context as a living playbook Agent failures are context failures. The ACE framework treats context as a playbook that grows through small updates instead of rewrites, and small open models gain the most from it. 2 min readShort post Context engineering
  119. Well-built agents close compliance gaps that manual processes leave Compliance teams block agents as too risky while manual processes run on memory and reconstructed logs. Properly architected agents make audit trails and enforcement automatic. 2 min readShort post Agent security and risk
  120. Onboard your AI assistant like a junior developer Teams spend weeks onboarding a junior developer and minutes onboarding their AI assistant. Both need the same thing: context, standards, and patience. 2 min readShort post Context engineering
  121. Three windows for adopting agentic coding are closing Teams that plan to adopt agentic coding in two or three years underestimate the learning curve, the talent market and the economics. Each of the three gives a reason to start the clock now. 2 min readShort post Adoption
  122. Use subagents as researchers, not implementers Subagents that implement directly lose context between sessions. Subagents that research, write their plans to the file system and leave the implementation to the main agent work in production. 2 min readShort post Coding agent setup
  123. Generic coding agents hit a limit, custom agents go past it Claude Code, Cursor and Gemini CLI are built for the average codebase. Teams that scale with agents move from better agents to more agents to custom agents built for their own domain. 3 min readShort post Coding agent setup
  124. Reduce and delegate: two ways to keep an agent's context focused A context window is not infinite RAM. First cut what never belongs in it, then spread the rest across sub-agents and context bundles so long tasks keep their focus. 3 min readShort post Context engineering
  125. Junior engineers gain the most from AI coding tools A year-long study of 300 engineers at one company found real productivity gains from AI coding assistants, the largest for juniors, and gains that track how intensively teams adopt. 1 min readShort post Measuring AI impact
  126. Five human skills that grow more valuable with AI My son asked why he should learn programming if AI will do it for him. The skills that matter most are becoming more valuable: critical thinking, empathy, language, value creation, judgment and taste. 2 min readShort post Adoption