Short pieces on engineering leadership, AI agents, and regulated systems.
Short-form pieces — usually 100–300 words — written first on LinkedIn and mirrored here. Filed by date, searchable by tag. Where the original lives on LinkedIn, the post links back. The version here is the canonical record.
The dangerous agent failure is not always a bad answer. Sometimes it is public input reaching private context.
GitLost showed a crafted public GitHub issue steering an agent with cross-repo read access into posting a private README as a public comment — no stolen credentials, just a context-separation failure. The agent runs on a service-account permission model, not a user one, so no patch closes it; the fix is architectural. If public text can steer private access, the permission model is already broken.
AI SecurityThe best hire is not always someone you can manage easily. Sometimes it is someone you would be willing to report to.
Strong leaders create leverage by hiring near-peers who turn direction into daily operating decisions, instead of task-takers who route every decision back through you. A near-peer multiplies judgment; a task-taker multiplies coordination. Hire only for delegation and you become the ceiling on everything the team can do.
Engineering LeadershipA model can get smarter and still make your system less reliable. That is what weak tool contracts do.
The newest Claude models regressed on one edit tool — inventing fields that did not match the schema, failing ~20% of the time in a real agentic session. Smarter model, worse tool behavior, only visible in a long history. The fix is not a better prompt; it is stricter schemas and runtimes that fail loudly. The tool contract is part of the product's intelligence.
AI EngineeringAI is getting good at reviewing code. That is exactly why the human's job in review has to move up.
An AI reviewer is good at the mechanical pass — but it misses the change that fits the diff and breaks the architecture. The reviewer's value moves up the abstraction stack, to the judgment and accountability the model structurally cannot supply. The mechanical reviewer can be automated; the one who owns the consequence cannot.
AI EngineeringThe model can be available and the deployment can still fail. The last mile is an engineering problem.
Enterprise AI depends on last-mile engineering: wiring AI into real tools, permissions, data, processes, and review gates. Buying capability is easier than absorbing it. The model is a purchase; the working system is a build.
AI TransformationIf an AI output is hard to evaluate, the problem may not be the eval. It may be the product boundary.
Good AI products make verification cheaper — decompose work into reviewable units, attach evidence, make the boundary between decided and inferred visible. Output that cannot be verified cheaply gets trusted blindly or ignored, and both are failures.
AI EngineeringAn agent retry loop can become an outage. That is not an intelligence problem — it is a systems problem.
Agents call tools, retry on failure, run in parallel, and resume after interruptions — every one a distributed-systems problem we already know is hard. A smarter agent does not reduce these risks, it raises them. The runtime has to survive what the intelligence plans.
AI EngineeringAn agent identity is not enough. Someone has to own what the agent is allowed to do.
Registering an agent as an identity is the easy half. The hard half is accountability — authentication answers 'who is this' while ownership answers 'who answers for what it does.' An agent with no owner is a latent incident that moves fast.
AI GovernanceYour team is shipping more code than ever. That is not the same as being more productive — and AI makes the gap dangerous.
Activity metrics were always proxies for human effort. AI makes output cheap, so output stops being evidence of value. The only metric that survives AI is the one tied to an outcome someone actually wanted.
Engineering LeadershipThe important part of Claude Tag is not that Claude joined Slack. It is that execution is moving into the collaboration layer.
When agents enter the place where teams discuss work, the operating risk shifts from prompting to delegation, context, permission, and ownership. AI adoption becomes workflow design, not chat integration.
AI TransformationA hidden AI guardrail is not governance. It is unobservable product behavior.
Users forgive limits more easily than mystery. In an AI workflow, a guardrail is part of the product surface — it needs a trace, a reason, a fallback, and a cost signal. The safety layer cannot behave like a hidden exception handler.
AI GovernanceAI can make a team faster and more exhausted at the same time. That is not a paradox.
More output without a redesign of review, ownership, and recovery time turns the productivity gain into a cognitive-load tax. AI adoption is not just a tooling rollout — it is a workload-design problem.
Engineering LeadershipPrompt engineering was the visible phase. Loop engineering is where AI starts becoming operating infrastructure.
A loop has a goal, context, a way to act, a way to evaluate, and a rule for what happens next. The hard part is not making it run — it is deciding what the loop is allowed to optimize and where it must stop.
AI EngineeringFor years an app was a screen you tapped through. It is quietly becoming a set of functions an agent can call without ever opening it.
With Android 17 AppFunctions, an app exposes its actions as callable tools and the screen becomes optional. When a machine can call your product directly, your permission model stops being plumbing — it becomes the product.
Product EngineeringYour product is no longer used only by people. It is also read, summarized, scraped, tested, and probed by machines.
Machine traffic has crossed human traffic, and a growing share is agents acting now, not crawlers indexing for later. Designing for machine readers is not marketing or security bolted on at the end — it is architecture.
Systems ThinkingYou can damage an engineering culture in the name of AI — and then wonder why the AI work keeps getting worse.
AI does not replace your engineering culture; it runs on top of it and amplifies whatever was already there. A rollout that trades away trust and ownership to buy visible activity is not transformation — it is an AI label on organizational debt.
Engineering LeadershipThe engineering job is moving from writing software to building the system that writes it.
Agentic code-review numbers show why a software factory is becoming urgent — and why the missing piece is the operator layer between stages, not the model.
Engineering LeadershipThe web's developer knowledge layer was built for humans. Agents need a different interface.
Stack Overflow for Agents treats software knowledge as an API-first, verified, continuously updated system — an admission that agentic development needs living knowledge with accountability attached.
AI EngineeringA privacy rail still has to prove its own supply.
The Zcash Orchard bug is a reminder that confidential balances and an auditable monetary system are two different requirements — and financial infrastructure has to satisfy both at once.
Financial InfrastructureThe next useful AI coding benchmark will not ask whether the model can write code. It will ask whether a maintainer would merge it.
Cognition's FrontierCode measures mergeability — correctness, test quality, scope discipline, and style — on repos maintainers actually own. Owning the consequence of a change is the part that still needs a human.
AI EngineeringYour most important dependency can be switched off by someone you have no contract with.
When a load-bearing dependency is governed by policy, pricing, or decisions you do not influence, you do not own your system — you rent it. Resilience is not a backup vendor; it is the right to substitute.
AI GovernanceAI search tracking is starting to look less like SEO ranking. It looks like polling.
After three identical ChatGPT runs, only 2.2% of citations stayed consistent. If the answer surface is probabilistic, a single prompt result is noise, not a position — so the method has to change.
AI SearchAI agents can read the code. They still cannot read the reasons.
Addy Osmani's 'Intent Debt' names one of the most expensive gaps in agentic engineering: the goals, constraints, and trade-offs that never got written down. Architecture records become control inputs for the tools that modify the system next.
Software ArchitectureYour model provider may also become your consulting competitor.
When frontier labs move into enterprise services, the API stops being a pure supplier relationship and can turn into a channel conflict.
Enterprise AIThe better the autopilot, the more dangerous the sleeping pilot.
Reliable automation improves throughput while quietly eroding the manual skill a team needs to recover when it fails.
Engineering leadershipAI infrastructure is starting to look less like cloud procurement. It looks like capacity diplomacy.
The critical object is not only compute, but the contract around compute: priority, cancellation, and what gets degraded first.
InfrastructureRecursive self-improvement is not just an AI research problem. It is an operating model problem.
The moment an AI system can improve the system that evaluates it, governance stops being a policy document and becomes part of the architecture.
GovernanceAI finding more vulnerabilities is not automatically a security win.
Security improves when detection is connected to execution capacity, not when the findings pile grows faster than the remediation queue.
SecurityAI made code cheaper. It made judgment more expensive.
As agents handle more of the implementation, domain expertise becomes the scarce skill that decides whether the output is actually correct.
Engineering leadershipStablecoins get interesting when they stop looking like a crypto feature.
A dollar-backed asset embedded into an existing remittance network turns the question from token speculation into payment infrastructure design.
FintechAI cost discipline is becoming an engineering leadership problem.
Cost problems in engineering organizations arrive as small exceptions, not all at once. The mature AI stack optimizes for cost per accepted outcome — useful work that survives review, deployment, and operating cost — not raw consumption.
Engineering leadershipThe enterprise AI winner may not look like a new AI app.
Enterprise AI is being absorbed into existing cloud, HR, finance, and IT systems through procurement, governance, and identity channels — not arriving as standalone apps. The platform shift runs through old systems gaining delegated action.
Enterprise AIFor agents, search is becoming programmable infrastructure.
As models gain control over retrieval pipelines, search stops being ranked links and becomes programmable infrastructure — with the operational problems that come with it: source quality, cost, repeatability, and auditability.
AI infrastructureAI infrastructure is becoming a platform-team problem.
Once agents reach production, the hard work moves into the operating layer — routing, cost control, observability, identity, and rollout safety. AI does not remove platform work; it expands the surface it has to cover.
Platform engineeringSecuring your own agents is no longer enough.
The next AI security problem is not the agent you deployed — it is the agent ecosystem you depend on. Treat the agent layer as a production dependency: scoped credentials, audited extensions, isolated profiles, and revocation paths.
AI securityAI does not remove the cost of carrying complexity.
The best engineering organizations will use AI to write less code, not more. Senior judgment is measured by value created per unit of complexity left behind.
Engineering leadershipWhen execution gets cheaper, deciding what deserves execution becomes the senior skill.
AI does not remove product judgment. It punishes weak product judgment faster. As execution compresses, value shifts toward adoption design, trust, and deciding what should not be built.
Product leadershipToken usage is the new lines-of-code metric.
AI adoption should be judged by useful shipped work, validated outcomes, and whether the workflow actually improved after the model entered it — not by activity volume.
Engineering managementCompliance software wins on evidence, not confidence.
AI can automate parts of compliance only when the system preserves control, accountability, traceability, and a defensible audit trail.
Regulated systemsAgents borrow blast radius. That's the problem.
An AI agent using a user's session is not automation. It is privilege amplification with a friendly interface.
ArchitectureAI coding becomes enterprise-grade when it survives finance, security, and maintenance.
The leadership question is no longer whether engineers will use coding agents. It is whether the organization can afford, govern, and maintain the workflow after the demo ends.
Engineering leadershipWere you represented correctly before the click existed?
As AI interfaces mediate discovery, companies need to optimize for machine interpretation, not only human landing pages. Vague structure becomes a distribution bug.
Operator takeAI is not killing content. It is killing plausible vagueness.
In a saturated market, generic positioning dies first. The only thing that still travels is a point of view with mechanism, context, and scar tissue in it.
PositioningYou know AI has escaped the demo when the network team starts complaining.
A technology becomes an operating reality when it changes traffic shape, permissions, and observability before it changes the org chart. Infrastructure symptoms are more honest than launch narratives.
Platform engineeringThe most dangerous part of an AI stack is rarely the model.
Repo workflows, tokens, plugins, post-login trust, and integration boundaries are where systems reveal whether they were built to be demoed or built to survive. Security is architecture with consequences attached.
Security architectureThe best forward-deployed people are not close to the customer. They are close to the truth.
The valuable part of forward-deployed work is not customer proximity. It is the ability to reduce ambiguity across product, architecture, and execution without hiding behind any one function.
Engineering leadershipThe most important layer in a modern product is often the one the user never notices.
As software becomes more agentic, value shifts from the polished interface to the structured artifact layer underneath — the thing humans and systems can inspect, update, validate, and reuse.
Systems designAI makes management a choice again, not the default path to influence.
For years “more impact” quietly meant “more people reporting to you.” AI raises the value of high-judgment operators who move work end to end, so titles should follow leverage, not compensate for its absence.
Engineering leadershipMost AI reorganizations are not about speed. They are confessions.
When a company redraws the org chart around AI, it is usually admitting the previous decision model can no longer carry the coordination load. The org chart changes after the operating model has already started failing.
Org designTokenization will not stall because the idea is weak. It will stall where trust changes hands.
In financial systems the hardest part of the next wave is not issuance or settlement logic. It is designing the trust boundary around action, custody, and liability — adoption fails on trust choreography, not thesis.
Fintech