ThoughtWorks Technology Radar v34

The latest edition of the always useful Thoughtworks TechRadar, v34, was published back in April. My notes below are mostly just a copy & paste from the original for the sections I found most interesting, mostly for my own benefit. I recommend reading the original from thoughtworks.com or direct from this pdf.

 

Highlights:

• AI theme continue to dominate with Claude Code and Cursor unsurprisingly make it, firmly, in to Adopt category.
• Model Context Protocol (MCP) as the default integration layer between AI agents and external systems is actively discourage where simpler alternatives exist.
• OpenClaw makes it on to the caution list. “The model requires substantial security trade-offs. The more access you grant it, the more useful it becomes, and the more it concentrates permissions”. A risk to be wary of.
• Claude Code plugin marketplace is on trial as a way to share commands, prompts and skills using a Git-based distribution model.

Themes

The challenge of evaluating technology in an AI world

Evaluating technology is becoming harder as the industry adopts AI. One contributing factor is semantic diffusion: the rapid emergence of new terms for evolving practices, often before their meanings have stabilized.

The pace of change compounds this uncertainty. AI has lowered the barrier to building developer tooling, creating a constant stream of new tools. But when something can be created quickly with little effort, what ensures continued investment in maintaining and evolving it?

 

Retaining principles, relinquishing patterns

AI is pushing us to revisit the foundations of our craft. We are returning to many established techniques, from pair programming to zero trust architecture, and from mutation testing to DORA metrics. And we revisit core principles of software craftsmanship, such as clean code, deliberate design, testability and accessibility as a first-class concern. All necessary counterweights to the speed at which AI tools can generate complexity.

AI-assisted software development represents a fundamental shift in engineering practice. How we collaborate and structure teams will need to evolve as we better understand what is possible with agentic systems. Ultimately, we’re likely only at the beginning of a deeper transformation in how we build, understand and interact with software systems.

Securing permission-hungry agents

The agents worth building require broad access to private data. However, the safeguards haven’t caught up with the ambition. The “lethal trifecta” of an unsafe agent – private data, untrusted content, external action – now describes most agents by default. Prompt injection, and inconsistent model behavior are both risks.

What can we do today? Zero trust, least privilege, model improvements and defense in depth are the table stakes.

Emerging practices such as Agent Skills as a controlled alternative to MCP, durable agents and techniques to prevent agent instruction bloat all point in this direction. Caution is essential to avoid a costly misstep.

 

Putting coding agents on a leash

As coding agents become more capable and produce better results, humans are increasingly being tempted to step out of the loop. To mitigate the risks of reduced human supervision, teams are beginning to invest in coding agent harnesses: controls that guide agents’ behavior before code is generated and provide feedback afterwards to enable self-correction.

Feedforward controls anticipate what the agent needs to increase the likelihood of a correct first attempt. Agent Skills help modularize instructions and conventions, and load them just in time.

Feedback controls, by contrast, observe behavior after the agent acts and create a loop for self-correction.

Techniques

Context engineering

Adopt

Unlike prompt engineering, which focuses on wording, context engineering treats the context window as a design surface.
Dumping raw data into large context windows leads to “context rot” and degraded reasoning. Instead of front-loading every instruction and reference an agent might need, progressive context disclosure systems start with a lightweight index of what’s available.

Dynamic retrieval goes beyond basic RAG by selecting tools and loading only the necessary MCP servers, avoiding unnecessary context expansion.

Treating AI context as a static text box is a fast track to hallucinations. To build resilient enterprise agents, teams must engineer context as a dynamic, precisely managed pipeline.

 

DORA metrics

Adopt

DORA metrics have been proven to be strong leading indicators of how a delivery organization is performing. These include change lead time, deployment frequency, mean time to restore (MTTR), change failure rate and a newer fifth metric, rework rate.

Rework rate is a stability metric that measures how much of a team’s delivery pipeline is consumed by unplanned rework to fix work previously considered complete, such as user-facing bugs or defects.

In the era of AI-assisted software development, the DORA metrics are more important than ever. Measuring productivity by lines of code generated by AI is misleading; real improvement must be reflected in delivery flow and stability. If lead times don’t decrease and deployment frequency doesn’t increase, faster code generation doesn’t translate into better outcomes. Conversely, degradation in stability metrics — particularly rework rate — provides an early warning sign of blind spots, technical debt and the risks of unchecked AI-assisted development.

As always, we recommend using these metrics for team reflection and learning. Simple mechanisms, such as check-ins during retrospectives, are often more effective than overly detailed tracking tools at improving capabilities.

 

Passkeys

Adopt

Passkeys can replace passwords using asymmetric public-key cryptography.

The private key is stored in a hardware-backed secure enclave on the user’s device, protected by biometrics or a PIN, and never leaves it*.

Major identity providers including Auth0, Okta and Azure AD now support passkeys as a first-class feature, and implementation has been simplified from a multi-month effort to a two-sprint project.

Teams should design account recovery carefully and avoid phishable fallback paths such as SMS OTP, which reintroduce
the vulnerabilities passkeys eliminate.

*My note: I think it is entirely possible for passkeys to leave your device. It is increasingly common for passkeys to be synched to the cloud (e.g. Apple’s CloudChain, or using Google’s password manager sync capabilities).

 

Agent Skills

Trial

Agent Skills, a form of context engineering, provide an open standard for modularizing context by packaging instructions, executable scripts and associated resources such as documentation. Agents load skills only when needed based on their descriptions, which reduces token consumption.

Skills have been adopted very quickly and are one reason teams are becoming more cautious about defaulting to MCP, as many use cases can be addressed just as effectively with skills.

We caution against unreviewed reuse of third-party skills, as they introduce serious supply chain security risks.

Mutation testing

Trial

Unlike traditional code coverage, which only tracks line execution, mutation testing introduces deliberate bugs (mutations) into source code to verify that tests fail. If a mutation goes undetected, it reveals a gap in validation.

This is critical with AI-assisted development, where high coverage percentages can mask logically hollow tests or generated code that has never been meaningfully asserted. Mutation testing acts as a reinforcement layer for catching “perpetually green” tests. The focus shifts from how much code is executed to how much code is actually verified.

Tools include:

• Stryker (JavaScript, C# and Scala; no Java)
• Pitest (Java only)
• cargo-mutants (Rust only)

MCP by default

Caution

We caution against using the Model Context Protocol (MCP) as the default integration layer between AI agents and external systems, when simpler alternatives exist.

MCP adds real value for structured tool contracts, OAuth-based authentication boundaries and governed multi-tenant access. It also introduces an “abstraction tax”: every protocol layer between an agent and an API loses fidelity, and for complex APIs those losses compound.

In practice, a well-designed CLI with good documentation (–help), structured JSON responses and predictable
error handling often gives agents everything they need without the protocol overhead.

Many things that might be achieved with an MCP can be handled by a CLI tool instead.

MCP makes sense when its governance and integration benefits outweigh the added complexity and potential fidelity loss.

 

Platforms

AG-UI Protocol

Trial

AG-UI is an open protocol and library designed to standardize communication between rich user interfaces and back-end AI agents.

AG-UI intentionally sits outside MCP, functioning as an interface layer between the frontend and the agent backend.

AWS Bedrock AgentCore

Trial

AWS Bedrock AgentCore is the agentic platform for building, running and operating agents at scale, similar to GCP Vertex AI Agent Builder and Azure AI Foundry Agent Service.

Port

Trial

Port is a commercial internal developer portal designed to improve developer experience by
centralizing software assets, automating workflows and enforcing engineering standards, giving platform teams a single source of truth for self-service workflows.

Port works well for organizations that want productized portal capabilities without investing heavily in platform engineering. Use if you need an internal developer portal capabilities quickly.

 

Replit

Trial

Replit is a cloud-native collaborative development platform that provides instant dev environments, real-time coding and integrated AI assistance right in the browser. It combines an editor, runtime, deployment and AI coding workflows into one unified platform, allowing developers to start coding immediately without any local setup; a great fit for prototyping together as a team. The environment is powerful enough to compete with traditional local IDEs.

Agent Trace

Assess

Agent Trace is an open specification proposed by Cursor looking to standardize AI code attribution. As adoption of coding agents increases, understanding who has modified code now extends beyond human developers to include AI-generated changes.

Agent Trace takes a vendor-neutral approach to defining how code changes are traced and is unopinionated about how those traces are stored.

Note however that at time of writing the agent trace github repo is giving a 404. Not sure why.

 

Tools

Claude Code

Adopt

Anthropic’s Claude Code is an agentic AI coding tool for planning and executing complex multi-step workflows. It is widely treated as a benchmark for capability and usability. The CLI agent landscape has expanded quickly, but Claude Code remains the preferred option for many teams. Its use now extends beyond code authoring into broader workflow execution, including specifications, stories, configuration, infrastructure, documentation and markdown-defined business processes. Claude Code continues to introduce features that other tools follow, such as skills, subagents, remote control and agentic team workflows.

Teams adopting Claude Code should pair it with disciplined operating practices. Complacency with AI-generated code can make systems harder to maintain and evolve.

We’re seeing growing attention to harness engineering as a way to implement context
engineering (topic-aware, scope-driven context selection) and curated shared instructions to make agentic workflows more reliable.

 

Cursor

Adopt

Cursor is alongside Claude Code as a default choice for our delivery teams; a comprehensive agentic environment with features such as plan mode, hooks and subagents. While terminal-based agents remain popular, using the agent within an IDE provides a rich experience for reviewing and refining plans before execution.

The adoption of the Agent Client Protocol, which standardizes communication between code editors (such as IntelliJ) and coding agents (such as Cursor) has made Cursor’s capabilities accessible within IDEs.

While productivity gains are evident, agentic autonomy still requires rigorous automated testing and human oversight to catch subtle regressions.

 

Claude Code plugin marketplace

Trial

Previously, sharing custom commands, specialized agents, MCP servers and skills was a manual process that relied on developers to copy and paste instructions from Confluence or other external sources. This often led to version drift, with team members using outdated project instructions.

Our teams are now leveraging the Claude Code plugin marketplace to distribute shared commands, prompts and skills using a Git-based distribution model. By hosting internal team marketplaces on GitHub or similar, organizations can distribute these artifacts more securely and consistently. Developers can then sync the AI-driven workflows and tools directly into their local environments via the CLI.

 

OpenClaw

Caution!

An open-source project in the “hyper-personal AI assistant” category. Users host their own instance, keep it continuously available and let it execute tasks through connected tools. OpenClaw creates a persistent personal experience that feels materially different from GenAI chat interfaces or typical coding agents.

But the model requires substantial security trade-offs. The more access you grant it — to calendar, email, files and communications — the more useful it becomes, and the more it concentrates permissions. This risk is not unique to OpenClaw; it applies to other implementations of the same pattern, including offerings from established vendors.

The hyper-personal assistant pattern itself remains permission-hungry and high risk.

 

Languages and Frameworks

React Native

Adopt

React Native is the default choice for cross-platform mobile development. React Native delivers responsiveness that rivals native implementations while maintaining a single codebase.
The ecosystem around it is mature and stable. While state management still requires careful planning, the productivity benefits of fast refresh workflows and shared skill sets outweigh these costs.

 

Tags: radar, techradar, thoughtworks, thoughtworkstechradar