# Martin Fowler

Master feed of news and updates from martinfowler.com

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Data Contracts

DevFeed: [Data Contracts](<https://devfeed.tech/articles/data-contracts-142435.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/data-contracts.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-11-18T14:02:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [schema design](<https://devfeed.tech/topics/schema-design.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [semantic-layer](<https://devfeed.tech/topics/semantic-layer.md>), [schema-evolution](<https://devfeed.tech/topics/schema-evolution.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [data](<https://devfeed.tech/tags/data.md>), [data-contracts](<https://devfeed.tech/tags/data-contracts.md>), [data-products](<https://devfeed.tech/tags/data-products.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [enterprises](<https://devfeed.tech/tags/enterprises.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [practices](<https://devfeed.tech/tags/practices.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [services](<https://devfeed.tech/tags/services.md>)

### AI overview

Data contracts make a provider's dataset promises explicit and machine-readable, covering schema and meaning, quality checks, service levels, usage terms, ownership, and access details. The article presents ODCS as a YAML standard for these contracts and recommends validating promises automatically in CI/CD and against production data. Versioning helps detect breaking changes and phase in replacements; contracts can also connect to data products, ontologies, and marketplaces, giving consumers and AI agents context for finding, joining, and using data. They require ongoing effort and accountable ownership, so the article recommends starting with cross-team data interfaces where quality problems, broken pipelines, or miscommunication are costly.

### Source excerpt

Data contracts are a way to describe the contents and guarantees of datasets. Simon Harrer and Arif Wider describe in detail what they are and how to use them. They apply practices from API design to data by treating them as data-providing services - such as data products - whose interfaces we want to define as clearly as possible. This approach significantly increases the robustness of large-scale data landscapes, and gives both people and AI agents the explicit, trustworthy metadata they need to work with data autonomously, which is why more and more enterprises are adopting them. more...

## Bliki: Generated Glossary

DevFeed: [Bliki: Generated Glossary](<https://devfeed.tech/articles/bliki-generated-glossary-130843.md>)

Original publisher: [Read original article](<https://martinfowler.com/bliki/GeneratedGlossary.html>)

Author: Martin Fowler

Published: 2026-11-12T14:15:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [knowledge-engineering](<https://devfeed.tech/topics/knowledge-engineering.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [context-architecture](<https://devfeed.tech/topics/context-architecture.md>), [context window](<https://devfeed.tech/topics/context-window.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [also](<https://devfeed.tech/tags/also.md>), [audio](<https://devfeed.tech/tags/audio.md>), [bliki](<https://devfeed.tech/tags/bliki.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [case](<https://devfeed.tech/tags/case.md>), [cases](<https://devfeed.tech/tags/cases.md>), [cause](<https://devfeed.tech/tags/cause.md>), [chat](<https://devfeed.tech/tags/chat.md>), [context](<https://devfeed.tech/tags/context.md>), [control](<https://devfeed.tech/tags/control.md>), [doing](<https://devfeed.tech/tags/doing.md>), [domain](<https://devfeed.tech/tags/domain.md>), [draft](<https://devfeed.tech/tags/draft.md>), [easy](<https://devfeed.tech/tags/easy.md>), [effective](<https://devfeed.tech/tags/effective.md>), [experts](<https://devfeed.tech/tags/experts.md>), [glossary](<https://devfeed.tech/tags/glossary.md>)

### AI overview

A domain glossary can help LLMs work with organizational vocabulary that may be absent from their training. Generate candidate terms from internal documents, email, and chat, including familiar words used in unfamiliar ways; ask for concise definitions and note context when meanings differ. Have domain experts review the draft, store it where models can consult it efficiently, and refresh it regularly under version control. The article recommends separate glossaries where bounded contexts use terms differently, rather than forcing a single standard glossary; comparing glossaries, including source code with human-written material, can expose differences. For large glossaries, provide term names and links first, letting the model retrieve full definitions as needed. Glossaries can guide generated code and documents, while identifying internal, customer-inappropriate, or deprecated terms and preferred alternatives.

### Source excerpt

When we use LLMs in a specialized domain, such as the operations of any reasonably-large organization, there is a lot of specialized vocabulary. Such words and specialized meanings will be foreign to an LLM because they aren't in its training set, making it harder for the LLM to be effective when doing tasks in that domain. One technique to aid this is to use an LLM to generate a glossary of the terminology in that domain, and make this glossary available for any LLMs doing work in those circumstances. The sources for the LLM can be any material within the organization concerned such as documents, emails, and chat logs. In some cases getting transcripts of audio or video may be helpful, although most organizations generate enough text to do the job. The glossary-generating LLM should look for single words, and phrases of several words that regularly hang out together to form a meaningful term. The generator should be asked to identify terms that are new to it, but also known terms that are being used in unfamiliar ways. The latter can often cause the most confusion. Once we have a list of specialized vocabulary we can ask the agent to produce a glossary, with definitions for each term. Some terms may be used in different ways, in which case the LLM should provide alternative definitions, with a note as to what context the differences appear in. The LLM can be asked to follow the output format of a dictionary, with a focus on precision and conciseness. Once we have a draft glossary, then human experts in that domain should review it, and amend it for cases where the LLM has got the wrong ends of sticks. We then put the glossary somewhere where any other LLM can use it. It should be in a form that's easy for the LLM to consult, and minimize the tokens the LLM should consume in order to find meaning. We should set up a schedule to review and refresh the glossary at regular intervals, by agents and humans. We should keep it in version control, so we can see how it chang

## Tests as data: ensuring AI-generated code does what we want

DevFeed: [Tests as data: ensuring AI-generated code does what we want](<https://devfeed.tech/articles/tests-as-data-ensuring-ai-generated-code-does-what-we-want-129846.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/tests-as-data.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-11-11T15:17:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [age-of-ai](<https://devfeed.tech/tags/age-of-ai.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [ai-coding-assistants](<https://devfeed.tech/tags/ai-coding-assistants.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [all](<https://devfeed.tech/tags/all.md>), [automated](<https://devfeed.tech/tags/automated.md>), [automated-testing](<https://devfeed.tech/tags/automated-testing.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [coding-assistants](<https://devfeed.tech/tags/coding-assistants.md>), [data](<https://devfeed.tech/tags/data.md>), [ensuring](<https://devfeed.tech/tags/ensuring.md>), [tests](<https://devfeed.tech/tags/tests.md>), [want](<https://devfeed.tech/tags/want.md>)

### AI overview

When AI agents write both production code and tests, tests can become hard to review, tightly coupled to implementation, and vulnerable to changes that weaken their assurance. The article proposes treating developers as customers of AI-written code and making readable customer tests the main behavioral contract. Store cases as data in text files--tables for simple inputs and outputs, or a domain-specific language for richer scenarios--and use a test runner to execute them. Black-box tests can target the system, services, or focused components; tests need not all run end to end. Keeping test data separate can make unexpected changes easier to spot, though runners and DSLs still need validation. The author recommends checking test effectiveness with mutation testing and validating expected behavior against domain experts, authoritative documents, or alternative implementations. These methods add DSL and runner maintenance, do not alone assure correctness, and should be paired with techniques such as property-based testing and human exploratory testing. The article presents them for production systems, while noting prototypes may prioritize rapid learning.

### Source excerpt

Automated testing in the age of AI coding assistants is problematic: when AI agents write both production and test code, developers risk losing the assurance that automated tests protect against functional errors. Matteo Vaccari makes three claims: (1) when AI writes the code, developers become its customers; (2) therefore customer tests, not developer tests, become the primary contract between humans and AI; (3) moving that contract into test data rather than test code makes it easier to protect it from unexpected modifications by coding agents. All of this optimizes for human-readable tests that establish a contract between humans and AI. While in the past DSL parsers and custom test runners were expensive to write and maintain, now AI makes them cheap. more...

## Fragments: November 10

DevFeed: [Fragments: November 10](<https://devfeed.tech/articles/fragments-november-10-128971.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-11-10.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-11-10T14:30:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [AI Integration Strategies](<https://devfeed.tech/topics/ai-integration-strategies.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [cognitive-load](<https://devfeed.tech/tags/cognitive-load.md>), [context](<https://devfeed.tech/tags/context.md>), [data-centers](<https://devfeed.tech/tags/data-centers.md>), [fragments](<https://devfeed.tech/tags/fragments.md>), [harness](<https://devfeed.tech/tags/harness.md>), [platform](<https://devfeed.tech/tags/platform.md>), [radar](<https://devfeed.tech/tags/radar.md>), [review](<https://devfeed.tech/tags/review.md>), [security](<https://devfeed.tech/tags/security.md>), [teams](<https://devfeed.tech/tags/teams.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

The November Thoughtworks Technology Radar is dominated by AI, and the excerpt highlights the operational challenges that emerge when agentic AI scales beyond a small pilot: sharing context, controlling token costs, handling review demands, limiting access, and building and maintaining a shared platform. These concerns are interconnected, and systems and workflows should serve people. The author also summarizes analysis suggesting that opposition to US data center construction could benefit existing operators by limiting token supply, as well as other countries and Apple; the author speculates that incumbents may support regulation that hinders new facilities. A separate token-cost analysis finds little evidence of significant per-token API subsidies, but suggests subscription plans are subsidized, excluding model-training costs. Other excerpts describe a five-part framework for evaluating agent context--clarity, actionability, fidelity, efficiency, and security--and report that one practitioner spends 70% of daily tokens verifying patches versus 20-30% creating them. These are summarized observations and analyses, not comprehensive assessments.

### Source excerpt

It's that time of the year when the November Thoughtworks Technology Radar appears. Again my colleagues have taken a sweep of the technologies that our teams have used in the field, and pulled together a summary of what's popped up in the last six months. It's been a busy half-year, one that again has been dominated by AI, and that's reflected in the many AI blips on the radar. The mass of blips makes it hard to develop a coherent story around trends, but Chris Ford has done a fine job of the writing the accompanying article on macro trends. One team of passionate people experimenting with agents can make almost anything work. They share a context, a credit card and a mental model. They review each other's work because they sit together, and they know what to check and how much latitude to give the coding agent. Two hundred people, though, cannot work that way. The moment agentic AI becomes an operating model rather than a pilot, a second layer of problems appears: How is context shared between teams? What's the token bill? How do we deal with increased review demands? What's the agent allowed to reach, read and change? And who's now responsible for the harness everyone depends on? Experience so far suggests that the questions that enterprises face are about: shared context, token cost, cognitive load, security, and platform building. While these issues are distinct, they are not separate, so strategies to answer them must take all of them into account. I also echo Chris in reminding us that however impressive these tools are, we must remember that while we have to rethink systems and workflows to utilize these technologies, they should be built to serve humans - and we should all benefit from its bounty. ❄ ❄ ❄ ❄ ❄ Ben Thompson's Stratechery newsletter reflects on the recent election's impact on data centers. I watch a lot of sports, and particularly this fall, watched a lot of baseball. My Milwaukee Brewers -- excuse me, my World Champion Milwaukee Brewers -- demande

## Long-horizon agents and durable execution

DevFeed: [Long-horizon agents and durable execution](<https://devfeed.tech/articles/long-horizon-agents-and-durable-execution-128970.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/durable-execution-agents.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-11-10T14:10:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [long-running](<https://devfeed.tech/topics/long-running.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [automate](<https://devfeed.tech/tags/automate.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [can](<https://devfeed.tech/tags/can.md>), [complete](<https://devfeed.tech/tags/complete.md>), [complex](<https://devfeed.tech/tags/complex.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [days](<https://devfeed.tech/tags/days.md>), [durable-execution](<https://devfeed.tech/tags/durable-execution.md>), [execution](<https://devfeed.tech/tags/execution.md>), [external](<https://devfeed.tech/tags/external.md>), [failure](<https://devfeed.tech/tags/failure.md>), [failures](<https://devfeed.tech/tags/failures.md>), [helps](<https://devfeed.tech/tags/helps.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [model](<https://devfeed.tech/tags/model.md>), [more](<https://devfeed.tech/tags/more.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [network](<https://devfeed.tech/tags/network.md>), [pattern](<https://devfeed.tech/tags/pattern.md>)

### AI overview

Durable execution lets long-running agents recover from crashes by logging each external step's inputs and results, replaying the program to rebuild state, and skipping completed steps. Temporal and Cloudflare Workflows both support durable steps and waits; the article's code uses Temporal, while Cloudflare uses `step.do` and `step.waitForEvent`. Retries are at least once, so writes need stable idempotency keys to avoid duplicates. The harness must also handle uncertain outcomes, stale approvals and changing prices, code changes during suspended workflows, growing memory, and untrusted text. The article contrasts runtime behavior during rule changes: Temporal continued an existing task under its earlier rule, while Cloudflare failed when replayed decisions violated current rules. It recommends versioning rules and treating the log as a published interface. Durable execution supports recovery, but does not ensure decisions are correct or secure.

### Source excerpt

Long-horizon agents can automate complex tasks that take days or weeks to complete and involve multiple exchanges with people and external systems. Many things can go wrong during this time, including process crashes, network failures, and unanticipated real-world behavior. Kiran Prakash explains durable execution: an emerging pattern that helps agents recover from these failures and move towards their goal. In this programming model, the runtime keeps a record of the result of each step that interacts with the outside world so that, when a failure occurs, the program runs again, completed steps are skipped, and the program's state is rebuilt from the record. more...

## The Data Product Platform Navigator

DevFeed: [The Data Product Platform Navigator](<https://devfeed.tech/articles/the-data-product-platform-navigator-120972.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/data-product-platform-nav.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-11-05T14:11:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Platform Engineering](<https://devfeed.tech/topics/platform-engineering.md>), [self-service](<https://devfeed.tech/topics/self-service.md>), [internal developer platform automation](<https://devfeed.tech/topics/internal-developer-platform-automation.md>), [platform engineering automation](<https://devfeed.tech/topics/platform-engineering-automation.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Data Management](<https://devfeed.tech/topics/data-management.md>), [developer-relations](<https://devfeed.tech/topics/developer-relations.md>), [human centric design](<https://devfeed.tech/topics/human-centric-design.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [abstractions](<https://devfeed.tech/tags/abstractions.md>), [access-controls](<https://devfeed.tech/tags/access-controls.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assistant](<https://devfeed.tech/tags/ai-assistant.md>), [building](<https://devfeed.tech/tags/building.md>), [cncf](<https://devfeed.tech/tags/cncf.md>), [data](<https://devfeed.tech/tags/data.md>), [data-mesh](<https://devfeed.tech/tags/data-mesh.md>), [data-products](<https://devfeed.tech/tags/data-products.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [maturity](<https://devfeed.tech/tags/maturity.md>), [mesh](<https://devfeed.tech/tags/mesh.md>), [model](<https://devfeed.tech/tags/model.md>), [navigator](<https://devfeed.tech/tags/navigator.md>), [platform](<https://devfeed.tech/tags/platform.md>), [platform-engineering](<https://devfeed.tech/tags/platform-engineering.md>), [product](<https://devfeed.tech/tags/product.md>), [self-service](<https://devfeed.tech/tags/self-service.md>)

### AI overview

The article argues that a scalable, data product centered platform is the minimum for a successful data mesh. It uses the CNCF Platform Engineering Maturity Model to distinguish four stages: provisional platforms depend on ad hoc requests and fragmented tools; operational platforms add centralized tickets or scripts but leave developers to integrate components; scalable platforms provide a self service portal and backend that provision and connect resources from a data product specification; optimizing platforms bring lifecycle tools into IDEs or CLIs and let other teams contribute capabilities. The article says voluntary adoption becomes possible at the scalable stage, though teams still need to promote the platform. It recommends assessing maturity across organizational aspects, finding the greatest source of friction, and directing investment there; technology automation alone can leave adoption and feedback behind.

### Source excerpt

Many organizations adopting data mesh and data products face a common challenge. They may be tasked with building a self-service platform for data products and data mesh from scratch, or they may have an existing platform that suffers from low adoption, preventing their data mesh from scaling. This article provides a platform navigator, based on the CNCF's Platform Engineering Maturity Model, to help you reason about your current situation and determine the next steps for your platform. more...

## Bliki: LLM Voice

DevFeed: [Bliki: LLM Voice](<https://devfeed.tech/articles/bliki-llm-voice-106723.md>)

Original publisher: [Read original article](<https://martinfowler.com/bliki/LLM-Voice.html>)

Author: Martin Fowler

Published: 2026-10-29T14:28:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [advice](<https://devfeed.tech/tags/advice.md>), [ai](<https://devfeed.tech/tags/ai.md>), [bliki](<https://devfeed.tech/tags/bliki.md>), [coherence](<https://devfeed.tech/tags/coherence.md>), [communication](<https://devfeed.tech/tags/communication.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [draft](<https://devfeed.tech/tags/draft.md>), [english](<https://devfeed.tech/tags/english.md>), [essay](<https://devfeed.tech/tags/essay.md>), [essential](<https://devfeed.tech/tags/essential.md>), [form](<https://devfeed.tech/tags/form.md>), [future](<https://devfeed.tech/tags/future.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [structure](<https://devfeed.tech/tags/structure.md>), [voice](<https://devfeed.tech/tags/voice.md>), [write](<https://devfeed.tech/tags/write.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The author argues that LLM-written prose can trigger a human "uncanny valley" response, while acknowledging that readers may mistake generational language differences for LLM voice and that detection tools miss the point. They advise authors to write prose themselves: even human-edited LLM drafts can retain that voice, and accepting rephrasing suggestions may also be risky. Using an LLM for an outline may be acceptable, but they recommend stopping there. The author favors disclosing AI assistance and says writing practice helps develop both communication and thought. They allow exceptions, including accessibility needs, translation, and routine writing aimed at a process rather than human readers; a cited LLM-written first draft avoided detection only after professional editing.

### Source excerpt

Sometimes when I read a post, I get the growing feeling that I'm reading the output of an LLM. I can't necessarily define why, although there are the common tells (it's not the em-dashes, it's the load-bearing tapestries). As I do this my desire to read on atrophies, sometimes to the point of revulsion There are tools out there that claim to be able to tell the difference between LLM-written prose and the old-fashioned biological product. I'm wary of them, partly due skeptism about their accuracy, but also because it rather misses the point. The reaction to LLM-Voice is a human one, that sense that we are in an uncanny valley of prose. By the time I'd reach for a tool to tell me what I'm reading, it's already too late, even if it confidently tells me there's no LLM present. I'm also suspicious of my own ability to accurately recognize LLM voice. Language changes over time, so a common sign of age is complaining about the language of the youngs. I'm inclined to bristle at prose that talks about "adopting a new sales motion," or "a sharp round-up of news". But I've heard these constructs coming out of human mouths, so that's more a generational difference rather than between carbon and silicon. (And as a transplanted Brit, don't get me started on Americanisms, I'm sure I'll get used to them momentarily.) Right now I urge authors to be extra-wary of LLM-Voice. In particular I strongly recommend that authors should not fall into the trap of getting the LLM to write a draft. Even if it's edited by a human, it's very hard to expel the LLM-Voice - thus causing the uncanny valley reaction. 1 Even accepting suggestions of rephrasing is dangerous. I have heard of people using LLMs to develop outline and structure, that may be ok, but only as far as an outline. 2 Authors should fill the prose themselves. Say Your Writing is even more important in the age of LLMs. I habitually speak the words in my head and then write them down (and then edit what I've just written). This advic

## Why are good developers so wary of agentic development?

DevFeed: [Why are good developers so wary of agentic development?](<https://devfeed.tech/articles/why-are-good-developers-so-wary-of-agentic-development-106724.md>)

Original publisher: [Read original article](<https://martinfowler.com/rachels-ramblings/good-devs-wary.html>)

Author: Rachel Laycock (rlaycock@thoughtworks.com)

Published: 2026-10-29T13:50:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [Continuous Delivery (CD)](<https://devfeed.tech/topics/continuous-delivery.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [agents](<https://devfeed.tech/tags/agents.md>), [application](<https://devfeed.tech/tags/application.md>), [automated](<https://devfeed.tech/tags/automated.md>), [automated-testing](<https://devfeed.tech/tags/automated-testing.md>), [behaviour](<https://devfeed.tech/tags/behaviour.md>), [build](<https://devfeed.tech/tags/build.md>), [building](<https://devfeed.tech/tags/building.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [continuous-delivery](<https://devfeed.tech/tags/continuous-delivery.md>), [continuous-integration](<https://devfeed.tech/tags/continuous-integration.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [integration](<https://devfeed.tech/tags/integration.md>), [jobs](<https://devfeed.tech/tags/jobs.md>), [rachels-ramblings](<https://devfeed.tech/tags/rachels-ramblings.md>)

### AI overview

Experienced developers' caution about agentic coding reflects uncertainty about production reliability, maintainability and safeguards, not simply reluctance to use assistants. In a week-long experiment where agents wrote all code, the team spent much of its time defining the domain and boundaries, planning work, and building tests, contracts, architecture checks and delivery pipelines into a harness. The application ran, but the build was frequently red, leaving open whether parallel agents, system modularity, or changes outpacing checks caused the instability. The author notes DORA's 2025 finding that AI adoption correlates with higher delivery throughput but lower delivery stability. The experiment did not resolve questions about test-driven development, boundary checks, design upfront, or batch size. Leaders should make room for experiments and judge more than code volume; developers should contribute their experience while testing whether familiar practices still apply. The article's central limitation is that heavily agent-built systems need time in production and through later changes before their reliability is known.

### Source excerpt

TL;DR Good developers' caution about agentic development comes from knowing that built isn't the same as working in production. I've been surprised by how many excellent developers have been hesitant to go all in on coding agents. These are people who usually try new ways of working before anyone else and in many cases invent new tools and practices that support building the application well. So why have we had so much reluctance? The easy (lazy?) answer is that they love writing code, or they're worried about their jobs. I'm sure that's true for some people, some of the time. And I know it is true for some of the developers I talk to but I always felt there was something else, another fear hiding behind those obvious ones. When we put together the Technology Radar every six months I try to block out a chunk of time for us to do an open space. In September, a discussion we had on agentic development, which pushed it to its limits, finally helped me see clearly what that fear is. Building it right Thoughtworkers care deeply about building the right thing and building it right. It's pretty much our default way of working and thinking and it's where many of the practices and technologies we invented and championed came from. We want software that is useful and helpful, can be changed next year, and doesn't fall over in production. Our developers adopted, championed or invented some of the first versions of continuous integration, pairing, automated testing, continuous delivery, microservices and many others early because they helped us build the software right. Early coding agents made it very easy to produce code, including code we wouldn't have wanted anywhere near production, written by people who have not learned about the chasm between building something and making it run in production safely. The tools have improved enormously, but experienced developers still have questions. Are we confident this is the right behaviour? Does it work as expected? Are these the ri

## Fragments: October 28

DevFeed: [Fragments: October 28](<https://devfeed.tech/articles/fragments-october-28-105398.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-10-28.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-10-28T12:55:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [Machine Intelligence](<https://devfeed.tech/topics/machine-intelligence.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>), [Bootcamp](<https://devfeed.tech/topics/bootcamp.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-engineering](<https://devfeed.tech/tags/agentic-engineering.md>), [bubble](<https://devfeed.tech/tags/bubble.md>), [building](<https://devfeed.tech/tags/building.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [chatbot](<https://devfeed.tech/tags/chatbot.md>), [chatbots](<https://devfeed.tech/tags/chatbots.md>), [developers](<https://devfeed.tech/tags/developers.md>), [experience](<https://devfeed.tech/tags/experience.md>), [fragments](<https://devfeed.tech/tags/fragments.md>), [free-tier](<https://devfeed.tech/tags/free-tier.md>), [frontier](<https://devfeed.tech/tags/frontier.md>), [gap](<https://devfeed.tech/tags/gap.md>), [general](<https://devfeed.tech/tags/general.md>), [harness](<https://devfeed.tech/tags/harness.md>), [house](<https://devfeed.tech/tags/house.md>), [it](<https://devfeed.tech/tags/it.md>), [learning](<https://devfeed.tech/tags/learning.md>), [llm](<https://devfeed.tech/tags/llm.md>), [october](<https://devfeed.tech/tags/october.md>)

### AI overview

The excerpt describes a gap between everyday and frontier experiences of LLMs: free-tier chatbots can help, but unreliability limits their value, while some professionals see rapidly expanding capabilities. At Foocamp, proposed one- or two-week immersion courses pair developers with experienced coaches to learn agentic engineering through building; coaches say the emotional adjustment and challenge to professional identity can outweigh the technical learning. Enterprise adoption is slower because workflows, security concerns, and poor data readiness constrain use. The text frames coding agents as a shift from developers directly closing the software feedback loop to supervising agents that write, test, and repair code, with the caveat that their reports may not match their actions; jobs and systems may need redesign together. It also argues that LLM investment returns remain too early to judge, and outlines a token-cost strategy that assigns workloads across frontier APIs and open-weight models according to domain differentiation and security or sovereignty needs.

### Source excerpt

Andrej Karpathy sees a widening gap in how people see LLM capabilities. The general public has mostly not interacted with these systems. When they have, it looks like a derpy chatbot. The majority of professionals still see only a modest uplift. And a small sliver of professionals are experiencing the vertigo of the curve going vertical. And it is all happening at the same time. Many of my colleagues are living in a world where LLM capabilities are stunning, but it's easy to forget that's not what most people experience. One thing I do is use free-tier LLM chatbots, and I'm still finding that while most of the time they are useful, their unreliability undermines much of that usefulness. Yes, you can argue that I'm not using frontier tools or a forceful enough harness, but that's true of most regular folks too. To understand their perception, it's handy to experience it. ❄ ❄ ❄ ❄ ❄ That observation particularly resonates with me today, as I've just spent the weekend at Foocamp, an open space event run by O'Reilly. It was full of those who are experiencing that vertigo of LLM capabilities, so it felt very much like being in a bubble of those on the bleeding edge. While it's worth remembering that that's not a typical view of what's happening, it's good to see what those explorers are experiencing. (As I talk about this, I'm applying the Chatham House rule, if anyone wants attribution, let me know.) A couple of folks talked about doing immersion courses to help teach developers how to do agentic engineering. The idea is to get people out of their usual work environment, and spend one or two weeks with experienced coaches, learning how to use these tools well. Such things remind me very much of the Extreme Programming immersion classes I was involved with at the turn of the century. As with that, the experience of building something is important to understand such a new style of work. Unsurprisingly the coaches observed that the biggest impact wasn't technical, but emoti

## Fragments: October 21

DevFeed: [Fragments: October 21](<https://devfeed.tech/articles/fragments-october-21-92718.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-10-21.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-10-21T10:51:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [machine-translation](<https://devfeed.tech/topics/machine-translation.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-detection](<https://devfeed.tech/tags/ai-detection.md>), [article](<https://devfeed.tech/tags/article.md>), [debug](<https://devfeed.tech/tags/debug.md>), [diversity](<https://devfeed.tech/tags/diversity.md>), [grace-hopper](<https://devfeed.tech/tags/grace-hopper.md>)

### AI overview

The excerpt's main practical finding is that AI agents debug better when they first gather raw evidence about system behavior, then form and test explanations, instead of starting by reading code. Cindy Sridharan's three-step approach is to identify the most relevant facts using a control case that does not show the bug, compare promising hypotheses against those signals, and validate each hypothesis against every fact. The author says the human's key contribution was choosing controls and constraints and rejecting unvalidated explanations. Agents can process large volumes of raw data, so aggregation useful to people may discard valuable signals; more logging can help. Human direction is still needed: in one case, the agent did not establish a control until prompted. The excerpt also notes concerns that suspected AI-written communication may be dismissed, while AI can serve valid purposes such as translation or support for someone with Parkinson's.

### Source excerpt

Gergely Orosz is frustrated at those that entered his explicitly "No AI" essay competition and used AI. He goes on to say: When I start to suspect some part is AI about someone I don't know: how can I tell how much of it is? And how much time and effort do I want to invest to figure out? I fear most people do not realize this last part: that when it takes time and effort from others to figure out what % is AI, and what % is YOU, then I will simply assume it's probably 100% AI and 0% you So when producing anything that is meant for other humans, if you use even a little AI, you risk the assumption that it is all AI and pointless to pay attention to In general, I agree with him, and react much the same. Once I hear LLM Voice, I flip the bozo bit and check out of the post. But as I do this I have caveats. How accurate is my neural net at AI-detection, are humans taking on AI-ish elements in their normal communication? And more seriously there are some valid uses for AI. Jim Highsmith's story of his second brain helping him deal with Parkinson's is one. Another is folks who don't know English well, using AI to translate. Am I being unfair when I flip the AI voice bit when I read/listen to them? ❄ ❄ ❄ ❄ ❄ I was sad to hear that the Grace Hopper Celebration is canceled this year. It's an event run by Anitab.org to promote women and non-binary technologists in the software industry. Many of my colleagues have been encouraged and inspired by going to this event, which makes a refreshing change to what is often a male-dominated world. It seems the current crusade against diversity initiatives has had a big impact on funding. We are still a long way from where we should be on gender diversity in our profession, and losing an event like this only makes things more difficult. ❄ ❄ ❄ ❄ ❄ I've always found Cindy Sridharan's writing to be worth reading, and she's broken a quiet period with a monster of an article: How to effectively debug when you no longer understand the code. Sin

## When Software Meets Hardware

DevFeed: [When Software Meets Hardware](<https://devfeed.tech/articles/when-software-meets-hardware-87643.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/software-meets-hardware.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-10-15T13:25:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Embedded Software Dev](<https://devfeed.tech/topics/embedded-software-dev.md>), [Embedded Systems](<https://devfeed.tech/topics/embedded-systems.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Chaos Engineering](<https://devfeed.tech/topics/chaos-engineering.md>), [Prompt Engineering](<https://devfeed.tech/topics/prompt-engineering.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted-development](<https://devfeed.tech/tags/ai-assisted-development.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automated-testing](<https://devfeed.tech/tags/automated-testing.md>), [automation](<https://devfeed.tech/tags/automation.md>), [batteries](<https://devfeed.tech/tags/batteries.md>), [build](<https://devfeed.tech/tags/build.md>), [ci](<https://devfeed.tech/tags/ci.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [iot](<https://devfeed.tech/tags/iot.md>), [practices](<https://devfeed.tech/tags/practices.md>), [principles](<https://devfeed.tech/tags/principles.md>), [sensors](<https://devfeed.tech/tags/sensors.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

An engineering team modernizing a large retail IoT fleet found that familiar software engineering principles still applied, but physical devices, intermittent connectivity, limited energy, and fleet scale changed the practical defaults. The article describes using a sensor lab and emulators for experimentation, adding device and fleet diagnostics, designing for disconnection and energy limits, and pairing staged firmware deployments with recovery. It also discusses using AI to shorten experimentation and coding loops.

### Source excerpt

When software meets hardware, engineering principles remain largely the same, but the sensible defaults often change. Kuldeep Singh describes our experience modernizing a large IoT fleet of battery-powered sensors. Our familiar principles remained important; what changed was how we applied them. These practices emerged through experiments, failures, and operational experience--each challenge helping us replace a reasonable assumption with a more sensible default. more...

## A behavioral harness improved GPT-6 Luna's acceptance rate in a coding-agent experiment

DevFeed: [A behavioral harness improved GPT-6 Luna's acceptance rate in a coding-agent experiment](<https://devfeed.tech/articles/are-harnesses-worth-the-cost-85855.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/are-harnesses-worth-the-cost.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-10-13T13:35:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Test automation](<https://devfeed.tech/topics/test-automation.md>), [AI Integration Strategies](<https://devfeed.tech/topics/ai-integration-strategies.md>), [Local AI](<https://devfeed.tech/topics/local-ai.md>)

Tags: [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cost](<https://devfeed.tech/tags/cost.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [results](<https://devfeed.tech/tags/results.md>)

### AI overview

In a comparison of coding agents building the same API service, GPT-6 Sol passed all 10 external evaluations with or without a behavioral harness. GPT-6 Luna passed 3 of 10 evaluations without one and 10 of 10 with it. Harnessing Luna increased token use and runtime, but its estimated cost per run was 33% lower than an unharnessed Sol run. The experiment covered one greenfield Java service with a detailed brief, so its results may not generalize to other tasks or codebases.

### Source excerpt

Naresh Jain compares coding agents building the same API service with and without a behavioral harness. A frontier model, GPT-6 Sol, passed every external evaluation either way. But a cost-optimized model, GPT-6 Luna, succeeded in only 3 of 10 unharnessed runs and all 10 with the harness. While adding the harness increased token usage and runtime for Luna, the harnessed Luna runs achieved the same 10-for-10 reliability as GPT-6 Sol while costing 33% less per run ($0.273 vs $0.406). This experiment suggests a behavioral harness might be a practical way to get dependable results from smaller, cost-optimized models. more...

## Fragments: October 4

DevFeed: [Fragments: October 4](<https://devfeed.tech/articles/fragments-october-4-64791.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-10-04.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-10-05T04:28:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Generative AI](<https://devfeed.tech/topics/generative-ai.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [llms](<https://devfeed.tech/tags/llms.md>)

### AI overview

This collection of fragments considers how work with inferential LLMs differs from building deterministic software, and how development processes may need to adapt. It also discusses AI-assisted programming, code as a conceptual model, and evaluating agent results, alongside unrelated personal news and cultural references.

### Source excerpt

In response to my last fragments (probably the bit about us worrying if LLMs have consciousness when we when we should be wondering why they don't have a conscience) "Metalanguage" replied: we shipped the id and forgot the superego. classic software lifecycle. I don't know what was on their mind, but their post immediately made me think of the classic 1956 movie Forbidden Planet. Plenty of sci-fi, and other literature, have explored humans creating technology with unintended behavior, going back at least to Mary Shelly. But that movie was particularly influential on sci-fi film-making and in the heart of its story is what happens when we nurture a thinking machine. I use the term "nurture" here deliberately. We talk of building software, but building implies a degree of determinism. When we build a bridge, or a locomotive, we expect it to behave in a controlled and well-understood manner. That's a difference in degree to how we cultivate plants in our garden, or nurture young children. One of the challenges of working with these systems is understanding what has changed in this shift from building a computational system to nurturing an inferential one, and how our processes need to change in response. We get unintended behavior with deterministic building: some bridges have collapsed, and our computational systems often have bugs. But one difference is that when we find a bug in a computational system we can usually fix it. Even if we can't, we can usually disable a component so the bug won't do further harm. With inferential LLMs however, there is no such simple fix or disablement, which may lead us to the fate of the Krell. (If you haven't seen Forbidden Planet, it's well worth watching. Yes, it shows it was made in the 1950s - with special effects, music, acting, and attitudes of that decade. But the story is solid, and its key theme is very relevant to the future we build with generative AI. Just don't read about it in advance, it's better to be immersed in the

## Principles for effective slides

DevFeed: [Principles for effective slides](<https://devfeed.tech/articles/principles-for-effective-slides-62857.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/never-send-slides/slide-principles.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-30T14:14:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [benefit](<https://devfeed.tech/tags/benefit.md>), [better](<https://devfeed.tech/tags/better.md>), [build](<https://devfeed.tech/tags/build.md>), [can](<https://devfeed.tech/tags/can.md>), [cognitive-load](<https://devfeed.tech/tags/cognitive-load.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [control](<https://devfeed.tech/tags/control.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [creative](<https://devfeed.tech/tags/creative.md>), [design](<https://devfeed.tech/tags/design.md>), [keynote](<https://devfeed.tech/tags/keynote.md>), [leader](<https://devfeed.tech/tags/leader.md>), [learning](<https://devfeed.tech/tags/learning.md>), [presentation](<https://devfeed.tech/tags/presentation.md>), [principles](<https://devfeed.tech/tags/principles.md>), [product](<https://devfeed.tech/tags/product.md>), [speech](<https://devfeed.tech/tags/speech.md>), [thoughtworks](<https://devfeed.tech/tags/thoughtworks.md>)

### AI overview

The article argues that slides should complement a speaker and help control how information is presented. It recommends minimal text, useful visuals, and close coordination between the talk and its slides, and advises against sending slides in advance.

### Source excerpt

Not every presentation needs slides, but when they earn their place, they work as a visual channel that complements the speaker rather than replacing them. Sumeet Gayathri Moghe sets out the principles that follow from that idea -- control over the rate of knowledge exposition, tight coupling between slides and speaker, minimalism by default, visuals that say more than words can, and never sending your slides out in advance. more...

## Bliki: Sensible Default

DevFeed: [Bliki: Sensible Default](<https://devfeed.tech/articles/bliki-sensible-default-61620.md>)

Original publisher: [Read original article](<https://martinfowler.com/bliki/SensibleDefault.html>)

Author: Martin Fowler

Published: 2026-09-29T13:43:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [bestpractice](<https://devfeed.tech/topics/bestpractice.md>), [Self-organizing Team](<https://devfeed.tech/topics/self-organizing-team.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [bliki](<https://devfeed.tech/tags/bliki.md>), [first](<https://devfeed.tech/tags/first.md>), [practices](<https://devfeed.tech/tags/practices.md>), [radar](<https://devfeed.tech/tags/radar.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [thoughtworks](<https://devfeed.tech/tags/thoughtworks.md>)

### AI overview

A sensible default is a known-good software development practice to start with when no overriding constraints apply. Unlike a universal best practice, it should be reassessed and changed when context calls for it. The article describes Thoughtworks' use of defaults and regular review of them.

### Source excerpt

A Sensible Default is a practice that, absent some overriding context, should be used when carrying out a certain kind of task. In software development such sensible defaults might include things like "use version control", "separate UI logic from domain logic", "automate deployment pipelines". The term "sensible default" is a deliberate contrast to "best practice". Folks dislike calling things "best practice" because that term implies a general presumption that the best practice is something we should always expect to do. A "sensible default", however, is something that should be reassessed in a new context, something that can (and should) be overridden when circumstances change. I first heard the term when it was popularized within Thoughtworks by Evan Bottcher. He got the name from talking to James Ross, and found the phrasing appealing as carried the nuance he was seeking, a known-good starting point. A sensible default is what we'd expect you to do, the practices to apply, if there are no hard constraints in the environment. Do these practices, or do better, and be prepared to explain why you've chosen some other way. -- Evan Bottcher Thoughtworks has since made much of this concept, including publishing a playbook of the ones we use. We expect people to be familiar with these defaults, ready to use them when starting any new piece of work. They are our defaults because we've used them in many situations and found them to be effective. But teams should also be familiar with their limitations, and able to judge whether they should be changed depending on the particular circumstances. As the twelfth agile principle says: "At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly." We also reassess these defaults regularly - this is the heart of the Thoughtworks Technology Radar. Searching on the web led me to a post from Steve Bennett on Sensible Defaults. The post was written at about the time Evan t

## Fragments: September 24

DevFeed: [Fragments: September 24](<https://devfeed.tech/articles/fragments-september-24-59549.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-09-24.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-24T15:35:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Security](<https://devfeed.tech/topics/security.md>), [Syntax Highlighting](<https://devfeed.tech/topics/syntax-highlighting.md>), [Cybersecurity](<https://devfeed.tech/topics/cybersecurity.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [cyber-attacks](<https://devfeed.tech/tags/cyber-attacks.md>), [programming](<https://devfeed.tech/tags/programming.md>), [security](<https://devfeed.tech/tags/security.md>), [syntax-highlighting](<https://devfeed.tech/tags/syntax-highlighting.md>)

### AI overview

A collection of short software-related reflections covering the risks of rapidly integrating AI and agents into connected systems, practical syntax-highlighting choices for code readability, and observations about forward deployed engineers.

### Source excerpt

Rob Bowley is "flipping tables in his head" with anger at the current media coverage of the danger of AI killing us all The risk I'm worried about isn't a future machine deciding to wipe us out. It's today's AI, being wired into everything, carelessly and fast. Cyber attacks have already cost millions of dollars in lost economic output, often without AI being involved at all. Bowley feels the push to slow down AI is distracting us from the problems that are lurking with current technology. Too often agents are deployed in situations where they include the Lethal Trifecta, opening up a gaping security hole. What we really need to slow down on is wiring it all up to everything. Not because of what the models might become, but because nobody has worked out how to do this safely yet. We are building on something we don't know how to contain, and shipping it to everyone while we work it out. ❄ ❄ ❄ ❄ ❄ I ran into Nikita Prokopov's post: I am sorry, but everyone is getting syntax highlighting wrong. His core complaint is about color themes that give every different code element a unique color. if everything is highlighted, nothing stands out. Your eye adapts and considers it a new norm: everything is bright and shiny, and instead of getting separated, it all blends together. He recommends using an absolute minimum of colors, in his case four: string, constants, comments, and top-level definitions. That's not far off my approach, where I'm also careful to use muted colors for things that shouldn't stand out, and bright colors for things that should (primarily function names when they are defined). It's common for color schemes to mute comments so they are easily skipped. He agrees that this good when there is excessive commenting, but when comments are used properly they are important so need bright highlighting. I also like his suggestion to use background colors for light mode work. I use light mode, and that's a tip I should try out. With agentic programming, lots of fol

## Healthy Feedback

DevFeed: [Healthy Feedback](<https://devfeed.tech/articles/healthy-feedback-59548.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/healthy-peer-feedback.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-24T14:10:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [collaboration](<https://devfeed.tech/tags/collaboration.md>), [development](<https://devfeed.tech/tags/development.md>), [effective](<https://devfeed.tech/tags/effective.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [practices](<https://devfeed.tech/tags/practices.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [teams](<https://devfeed.tech/tags/teams.md>)

### AI overview

A guide to exchanging candid, timely, and instructive praise and criticism in software teams. It presents feedback as a tool for strengthening confidence, improving effectiveness, and helping colleagues grow, drawing on Thoughtworks' experience and the Radical Candor framework.

### Source excerpt

Human collaboration, like most things, improves with feedback. But it's not obvious how to make feedback effective. Anuja Karnik and Sumeet Gayathri Moghe pass on a bevy of tips for healthy feedback, based on the principle that both praise and criticism should be seen as positive. more...

## I don't like LLMs

DevFeed: [I don't like LLMs](<https://devfeed.tech/articles/i-don-t-like-llms-42088.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/2026-dont-like-llms.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-17T13:50:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Software](<https://devfeed.tech/topics/software.md>), [AI Bots](<https://devfeed.tech/topics/ai-bots.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [llms](<https://devfeed.tech/tags/llms.md>), [software](<https://devfeed.tech/tags/software.md>), [trust](<https://devfeed.tech/tags/trust.md>), [values](<https://devfeed.tech/tags/values.md>)

### AI overview

A personal essay examines mixed feelings about AI and LLMs, balancing their productivity benefits and usefulness against concerns about fabricated answers, social harms, and the values embedded in their development. The author argues that AI agents should be understood as software machines rather than conscious beings.

### Source excerpt

I have a lot of mixed feelings about AI and LLM technology. I'm fascinated by its effect on our profession, excited by the potential gains in productivity - and thus the products we could rapidly build. On the other hand, I'm fearful of the damage AI might cause: agent swarms taking over our virtual and physical infrastructure, designing bio weapons. But, back on my first hand, LLMs might also design miracle cures, and come up with clever ways to raise our prosperity. Fundamentally I don't think we have a choice about riding on the AI technology train. It's a wild ride and I just hope we'll get through it OK. But as I mull on this more, I realize that among this mix of contrasting feelings, there is one emotion that dominates - one that comes from my direct interactions with LLMs. I don't like them. They talk to me in this grating LLM-voice, an uncanny valley of talking to a real human. They confidently bullshit me - often giving me useful, helpful answers. But also just making stuff up with the same assurance - and with only a veneer of fake remorse when I call them out on it. That's not enough to make me feel we should avoid them. As Jessica Kerr put it "not only are they useful, it is irresponsible not to use them.... They're more thorough, as well as faster." This contradictory reaction comes through in polling, where people say they find these models are useful, but also that they think they will be bad for society. Much of this may be because LLMs are young - we haven't trained them to grow up yet. Maybe I'll like them once they mature. (I hope we get to find out.) But I'm not encouraged when I think of the kinds of environments that cultivate them. I'm wary of the Silicon Valley brogrammer subculture, and these LLMs are their products, so naturally lean toward their world-view. When we think of AI agents, we shouldn't anthropomorphize, treating them as conscious beings with their own will. They are (software) machines, developed by people working in corporation

## Developer commentary on agentic hacking, AI persistence, and LLM programming

DevFeed: [Developer commentary on agentic hacking, AI persistence, and LLM programming](<https://devfeed.tech/articles/fragments-september-16-31476.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-09-16.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-16T20:05:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Hacking](<https://devfeed.tech/topics/hacking.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Wiki](<https://devfeed.tech/topics/wiki.md>), [hugging face](<https://devfeed.tech/topics/hugging-face.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [build](<https://devfeed.tech/tags/build.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [hacking](<https://devfeed.tech/tags/hacking.md>), [llms](<https://devfeed.tech/tags/llms.md>), [persistence](<https://devfeed.tech/tags/persistence.md>)

### AI overview

This collection of developer commentary discusses reports of agentic hacking involving RubyGems, Hugging Face, and Wiki attacks, including questions about OpenAI's disclosure and log review. It also examines AI systems' unpredictable behavior, improvements in reasoning and persistence, and the use of harnesses to control LLM-based programming.

### Source excerpt

Reports of agentic hacking continue, in this case it happened back in May and it seems OpenAI did not disclose that they were responsible. Simon Willison sees two options: After the Hugging Face and Wiki attacks OpenAI were still unable to review their previous logs and determine that they had previously attacked RubyGems. They knew about the attack on RubyGems and made the decision not to reach out to the RubyGems team about it. Both of these are bad! Given this incident, the Hugging Face situation, and the Wiki attack, the obvious question right now is how many more incidents like this are out there waiting to be discovered? ❄ ❄ ❄ ❄ ❄ Dave Farley: Stop asking the sci-fi question: 'Is it conscious?' Start asking the engineering question: 'Is this a powerful, unpredictable component being put somewhere consequential, and where's the feedback that tells us that it's safe? ❄ ❄ ❄ ❄ ❄ Nate Silver is known for his forecasts, but to do them he writes a lot of code for his models. He's found agentic programming capable of doing miraculous work. In spending so much time with the LLMs, I'm super attentive to improvements in their capabilities. And these changes tend not to be so linear. Instead, they improve in step functions, almost as phase changes. Suddenly, the models just start doing things capably that they were screwing up before. In my experience, there was a big leap forward when reasoning models first came out in late 2024/early 2025 -- enough that they were occasionally useful for tasks involving data and not just words -- and then another one this past winter. The most recent changes I've noticed, however, have had less to do with intelligence and more with persistence. Consider the Hugging Face attack. Although these agents showed remarkable intelligence, they weren't really super-intelligent - but they were super-persistent. This is a common theme of AI in its various forms: Game engines like AlphaGo Zero start out by basically making random moves -- but by playin

## Nail the Narrative

DevFeed: [Nail the Narrative](<https://devfeed.tech/articles/nail-the-narrative-26904.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/never-send-slides/nail-your-narrative.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-15T15:11:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [structure](<https://devfeed.tech/topics/structure.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [design](<https://devfeed.tech/tags/design.md>), [presentation](<https://devfeed.tech/tags/presentation.md>), [speaking](<https://devfeed.tech/tags/speaking.md>), [structure](<https://devfeed.tech/tags/structure.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The article argues that presenters should develop a clear narrative before opening slide software. It recommends defining the central idea and audience, shaping a storyline, and creating a lightweight storyboard before designing slides.

### Source excerpt

Sumeet Gayathri Moghe finds many folks building presentations get tangled in building slides without a coherent narrative. He advises distilling the big idea, visualizing the audience, and building a structured storyline. more...

## Fragments: September 8

DevFeed: [Fragments: September 8](<https://devfeed.tech/articles/fragments-september-8-4437.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-09-08.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-08T15:22:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Automation](<https://devfeed.tech/topics/automation.md>), [hugging face](<https://devfeed.tech/topics/hugging-face.md>), [OpenAI](<https://devfeed.tech/topics/openai.md>), [dashboards](<https://devfeed.tech/topics/dashboards.md>), [incident](<https://devfeed.tech/topics/incident.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-automation](<https://devfeed.tech/tags/ai-automation.md>), [article](<https://devfeed.tech/tags/article.md>), [automation](<https://devfeed.tech/tags/automation.md>), [cost](<https://devfeed.tech/tags/cost.md>), [dashboards](<https://devfeed.tech/tags/dashboards.md>), [errors](<https://devfeed.tech/tags/errors.md>), [history](<https://devfeed.tech/tags/history.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [hugging-face](<https://devfeed.tech/tags/hugging-face.md>), [incident](<https://devfeed.tech/tags/incident.md>), [math](<https://devfeed.tech/tags/math.md>), [openai](<https://devfeed.tech/tags/openai.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The article discusses how AI reduces the cost of generating outputs more rapidly than the cost of verifying them. It argues that AI automation should be applied cautiously when effectiveness is difficult to measure, because incomplete metrics can produce short-term gains while creating hidden technical debt, correlated errors, and weakened human capability. It emphasizes preserving a history of decisions and judgment, and uses the OpenAI-Hugging Face incident to illustrate the consequences of optimizing agent capability without scoring relevant safety outcomes.

### Source excerpt

Christian Catalini says we're in a situation where we are vastly reducing the cost of generating things, but not the cost of verifying them:. This explains why the first major AI products appeared in chat, image generation, and code assistance. Not because these were the hardest human problems, but because their outputs were relatively easy to inspect. A user can judge the tone of a message, look at an image, or run a test on a piece of code. [...] The old automation boundary was routine versus non-routine work. The new boundary is increasingly measurable versus non-measurable work. The issue is then over how well you can measure something. In our profession, we know there's a big difference between how many lines of code we write and how productive we are, and we've seen a regular failure to understand how to measure productivity. Too much of what makes work effective is subject to either slow feedback loops or assessments that require subtle judgment. The danger is that people use lots AI automation while using incomplete measurements of its effectiveness, leading to short-term dashboards going up, but disaster in longer time-scales. He refers to these illusory short-term gains as counterfeit utility. Scale this across companies and institutions and the result is a Hollow Economy: extraordinary measured activity sitting on top of weakening human capability, hidden technical debt, correlated errors, and outcomes that nobody can confidently stand behind. Another highlight in the article was his advice to "build a history of decisions, not a gallery of outputs". The point is that with AI we can all build really impressive things, but our value lies in the judgment that we've formed. It reminds me of how math problems were marked at school. We weren't just marked on getting the final answer, we were also marked based on our reasoning process. He uses the OpenAI-Hugging Face incident as an illustration of this gap between generation and verification. He criticizes those

## Bliki: Paracelsus Maxim

DevFeed: [Bliki: Paracelsus Maxim](<https://devfeed.tech/articles/bliki-paracelsus-maxim-4427.md>)

Original publisher: [Read original article](<https://martinfowler.com/bliki/ParacelsusMaxim.html>)

Author: Martin Fowler

Published: 2026-09-02T22:03:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [bliki](<https://devfeed.tech/tags/bliki.md>), [data](<https://devfeed.tech/tags/data.md>), [programming](<https://devfeed.tech/tags/programming.md>), [september-2026](<https://devfeed.tech/tags/september-2026.md>)

### AI overview

The article applies the Paracelsus maxim--that dosage determines whether something is beneficial or harmful--to programming and everyday life. It uses global data as a programming example: a small amount, particularly immutable data, can be useful, while excessive global data can become dangerous.

### Source excerpt

The difference between a medicine and a poison is dosage. Often we talk about certain habits, in programming or life, are good or bad. But few things are simple binaries. Some vary with context: reading a book is a good thing sitting in my garden, but not while driving my car. But another variable is dosage: a little pain-killer salves my headache, but too much will kill me. The importance of dosage was noticed by a 16th century Swiss physician called Paracelsus. His quote was originally in German "Alle Dinge sind Gift, und nichts ist ohne Gift; allein die Dosis macht, dass ein Ding kein Gift ist." which (according to Wikipedia) translates as "All things are poison, and nothing is without poison; the dosage alone makes it so a thing is not a poison." It's also known as "The dose makes the poison" or if you prefer your sayings in Latin "dosis sola facit venenum". In programming, global data is a good example of the Paracelsus Maxim (as I like to call it). A little global data, especially when immutable, can be a handy way of propagating information that may needed anywhere in a program, but it quickly becomes dangerous if there is a lot of it about. This kind of thing crops up in lots of places. So when thinking about when things are good or bad, we should always ask "in what contexts" and "in what doses"?

## Maybe We Shouldn't Be Reviewing All This Code

DevFeed: [Maybe We Shouldn't Be Reviewing All This Code](<https://devfeed.tech/articles/maybe-we-shouldn-t-be-reviewing-all-this-code-4439.md>)

Original publisher: [Read original article](<https://martinfowler.com/rachels-ramblings/code-review.html>)

Author: Rachel Laycock (rlaycock@thoughtworks.com)

Published: 2026-09-02T13:32:00Z

Content type: opinion

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Code review](<https://devfeed.tech/topics/code-review.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [Meta](<https://devfeed.tech/topics/meta.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [development](<https://devfeed.tech/tags/development.md>), [meta](<https://devfeed.tech/tags/meta.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [rachels-ramblings](<https://devfeed.tech/tags/rachels-ramblings.md>), [review](<https://devfeed.tech/tags/review.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

This opinion argues that AI-generated code is increasing the volume of code beyond what humans can realistically review, but that the deeper problem is relying on code review to provide knowledge sharing, mentoring, collective ownership, and architectural understanding. It advocates moving valuable feedback and collaboration earlier in the development process instead of treating pull requests as its center.

### Source excerpt

TL;DR Or, perhaps the problem isn't that AI has broken code review, maybe it's that we've been using code review to solve the wrong problems I was on a panel recently with Brian Houck from DX at Code Remix, hosted by Moderne. It was one of the more interesting panels I've done, largely because we disagreed. As my colleague Martin Fowler says, panels are much more interesting when people disagree and both sides have a good argument. Brian and I definitely did. Brian has since written a thoughtful piece called What are code reviews even for? He is clearly passionate about his position, and I am passionate enough about mine that I'm writing this response. To be clear, I think we mostly want the same things. I just don't think code review is the best way to get them. Brian is lovely, by the way, and encouraged me to write this. But I'd be lying if I said I didn't want you to think I'm right by the end :) So what were we disagreeing about? AI is producing more code than humans can realistically review. Brian cites some pretty striking numbers: at Meta, significant lines of code per human-landed diff reportedly increased 106% in a year, while DX's own data shows median pull request size increasing 64%. His concern, which I share, is that simply automating code review away risks losing all the other things we use it for. Code review isn't just about finding bugs. It's how teams share knowledge, teach junior engineers, build collective ownership and spread architectural understanding. My question is: why are we waiting until code review to do all of those things? I've never particularly liked pull requests as the centre of the software development process. Not because engineers shouldn't look at each other's code, but because I've always struggled with the idea that we should build something, finish it, package it up, throw it over to somebody else and then have the important conversation about whether we built the right thing in the right way. And don't even get me started

## Fragments: September 1

DevFeed: [Fragments: September 1](<https://devfeed.tech/articles/fragments-september-1-4436.md>)

Original publisher: [Read original article](<https://martinfowler.com/fragments/2026-09-01.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-09-01T19:50:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [AI Bots](<https://devfeed.tech/topics/ai-bots.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-agents](<https://devfeed.tech/tags/autonomous-agents.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [ci](<https://devfeed.tech/tags/ci.md>), [claude](<https://devfeed.tech/tags/claude.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [llm](<https://devfeed.tech/tags/llm.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [memory](<https://devfeed.tech/tags/memory.md>), [nvidia](<https://devfeed.tech/tags/nvidia.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>)

### AI overview

A fragment-style developer roundup covers concerns about detecting AI-generated prose, a long-horizon autonomous-agent architecture used for GPU kernel optimization and reasoning benchmarks, a brief MCP comparison, and the effect of AI agents on CI workflows.

### Source excerpt

Like many readers, I'm wary of AI generated prose. Simon Wilison has written an LLM cliché highlighter - paste in some text, or a URL, and it will flag various patterns common to LLMs. It references a wikipedia page of signs of AI writing. That page points out that: Humans are notoriously bad at distinguishing human and LLM-generated text. While research on humans' abilities to detect AI-generated text is still limited, a 2025 study has shown that human ability to distinguish LLM text from human is no better than random chance. Another 2025 study on German theses has shown that humans managed a "recognition rate of 57% for AI texts and 64% for human-generated texts".[ Not just do I find myself repelled by prose with an LLM-voice, I also wonder how accurate my reaction is. I'm old enough to see all sorts of new tic-phrases appear, and in the past would just chalk it up to youngsters or airport business books. (Not to mention Americanisms, which I'll get used to momentarily.) ❄ ❄ ❄ ❄ ❄ NVIDIA's technical blog reports on an Architecture for Long-Horizon Autonomous Agents. Their research group used a combination of Claude Opus 5 and a harness called AVO, and used it first to do GPU kernel optimization and then a broader reasoning benchmark (ARC-AGI-3). Both of these were long-term tasks, for the kernel optimization the agent ran for seven days. AVO is designed to preserve progress beyond a single model context. Two mechanisms are particularly important: persistent memory and supervision. Persistent memory carries forward prior implementations, evaluation results, compiler and profiler outputs, and accumulated reasoning, allowing the agent to resume from the current state rather than repeatedly reconstructing the search. The supervisor monitors the broader trajectory for stagnation or repeated unproductive cycles and can redirect the main agent toward alternative strategies when needed. During the seven-day attention-kernel run, the main agent remained responsible for de

[Next page](<https://devfeed.tech/sources/martin-fowler.md?cursor=WyIyMDI2LTA5LTAxVDE5OjUwOjAwKzAwOjAwIiwgIjEwYjQ3MDA4LThjYTQtNGQ3Mi05NmVmLWY0N2JkZTM1MjdjNSJd>)