The developer stories enterprise IT leaders actually read.
Volume 343, Issue 2 · 19 articles from 2 issues
Twelve AI coding tools tested on the same demo app, from GitHub Copilot and Cursor to Claude Code, Codex and open source Cline.
Citing Stack Overflow's 2026 survey finding that 73% of developers use AI coding tools daily, Techiexpert ranks 12 tools: GitHub Copilot (best overall), Cursor, Claude Code, OpenAI Codex, Windsurf, Augment Code, Amazon Q Developer, Gemini Code Assist, Tabnine, Cline, Aider and Lovable.dev.
Each tool was given the same four tasks on a marketplace demo app: explain the structure, fix a cart minimum-quantity bug, add sort-by-price and write unit tests.
The guide compares features, pricing (mostly around $20 a month for individual plans) and limitations.
It suggests Tabnine for privacy and Augment Code for large codebases.
In the agentic development life cycle, engineering expertise shifts upstream into specifications and approval gates.
The author compares agentic coding to early auto assembly, where fitters' skills moved into jigs and gauges.
One team built three systems over 18 months: the first took seven months, the second four, and the third five weeks with two engineers instead of twelve.
In the ADLC, engineers specify intent and own approval gates while agents plan, write and review code, test, deploy and triage.
Production issues should produce durable upstream artifacts such as contract clauses, regression tests or shared context updates, or the same defects recur.
Make evidence and blast radius conditions for accepting agent-generated code instead of reading every line.
Markus Eisele argues that reviewers have the same time they had before code generation became cheap, so reading every line limits throughput.
His approach is to agree on intended behavior and expected blast radius before implementation, then require evidence that shows drift and where direct inspection is needed.
In his example, an agent correctly adds refund approvals above 100 euros but also adds timeout retries to a shared payment client, which could issue duplicate refunds across all transactions even though the tests pass.
Treating blast radius as its own review criterion catches what line counts and passing tests miss.
Survey of 300 engineering leaders finds AI coding agents shift the bottleneck to debugging and code comprehension.
A Coleman Parkes survey of 300 senior engineering leaders on mission-critical, mostly C/C++ codebases found that AI coding agents have moved the bottleneck from writing code to debugging and understanding it.
Teams spend 9.8 hours a week producing code but 16.9 hours debugging, about 42% of the working week, and 35% of AI-generated code reaches production before the team fully understands it.
With 80% saying agents struggle with hard problems in complex codebases, many teams use agents for comprehension and debugging only in straightforward codebases.
Developer AI use keeps rising while trust lags, giving GitHub a role as the place to inspect and accept AI changes.
Stack Overflow surveys show AI tool use in development rising from 44% in 2023 to 83% in 2026, while only 7% of developers trust AI with important work decisions, a figure that rises to 48% if output is easy to check.
The column argues that GitHub can close that trust gap by helping teams inspect, test and review changes from any agent, including Claude or Codex.
As more tools propose code changes, organizations need continuity in how they accept them, which could make GitHub's core collaboration features more valuable than its own Copilot.
Instagram Direct's move to Jetpack Compose halved UI code and cut AI agent token costs per session by 33%.
Instagram Direct migrated its Android UI from the legacy View system to Jetpack Compose, designing the codebase so AI coding agents can understand and modify it more easily.
Engineers report that UI code volume fell 50% and token costs per agent session fell 33%.
Rather than prompting agents to migrate components piecemeal, the team focused on an architecture where the path of least resistance for agents is also the correct one, with clear boundaries around state management and predictable patterns.
Without that structure, agents introduce subtle bugs and tech debt.
Hannah Foxwell's QCon London talk on how agentic coding forces leaders to rethink team dynamics, safety and the human side of engineering.
In this InfoQ presentation from QCon London, platform engineering consultant Hannah Foxwell examines how the surge in agentic coding is changing engineering teams.
Noting the profession's long obsession with velocity, she offers three anchors for navigating AI-driven speed: building software worth building, prioritizing automated safety over raw speed, and preserving the human element.
That includes developing generalist 'broken comb' skill sets and keeping on-call practices sustainable so teams stay healthy as agents take on more of the coding work.
Enterprise AI coding is now a governance purchase; this ranking covers developer agents and governed app-building platforms.
The article argues that once business teams began vibe coding their own internal apps, enterprise AI coding became a governance decision about what gets built and what data it touches.
It ranks tools across two lanes, developer assistants and agents, and governed business app building.
The criteria are SSO, RBAC, audit logs and spend limits, where code and data run, fit with Git, IDEs and CI, and pricing clarity.
Superblocks ranks first for governed cross-enterprise building, followed by GitHub Copilot, Claude Code, Cursor, OpenAI Codex, Amazon Q Developer (moving to Kiro), Gemini Code Assist and Tabnine.
After Claude Code ported his 1970s BASIC game in under a minute, a veteran developer asks if legacy rewrites are next.
The author recounts spending months porting a BASIC Star Trek game to an IBM 5100 in the 1970s, then watching Claude Code convert it to WebAssembly via Go in under a minute.
He argues it will not be long before AI can tackle large legacy codebases written by many people over decades, the big balls of mud that no one fully understands.
The column considers what that means for teams maintaining millions of lines of legacy code and why the long-deferred rewrite may soon be practical.
Salesforce low-code automations are cheap to build but expensive to understand unless treated as software.
A production support practitioner explains that low-code platforms lowered the barrier to building automation but not to understanding it.
Mature Salesforce orgs accumulate unmigrated workflow rules, partly migrated Process Builder processes, layered record-triggered flows, legacy Apex triggers and managed-package logic that no one owns.
Chains of automations interact in ways no individual can trace, and when volume rises, recursive updates, order-of-execution surprises and governor-limit failures surface together, usually through user complaints rather than alerts.
The fix is to support low-code with software engineering discipline.
Anthropic built Scion after daily merges jumped from 2,500 to over 30,000, but has no plans to release it.
Anthropic's daily code merges rose from about 2,500 in May 2026 to more than 30,000 in September, straining its git-based infrastructure.
Its in-house version control system, Scion, has a 200x smaller CPU and memory footprint than the previous git-mirroring setup and lets CI and research jobs check out code two orders of magnitude faster.
Anthropic expects other companies to hit similar bottlenecks but has no plans to release Scion.
Instead, it says it wants to work with GitHub, GitLab and the open source community to bring some of its ideas to git.
Rather than crowning a winner, this guide offers a framework to pilot coding LLMs on your own repos and gate them in CI.
Anthropic, Google, OpenAI and SpaceXAI have all shipped new models since September, alongside open-weight families from DeepSeek, Qwen and Mistral, and the article argues that leaderboards go stale and can't predict behavior in your repositories.
Stack Overflow's 2026 survey found that 80% of developers use two or more AI tools and two-thirds switched tools this year.
The proposed framework is to define tasks and acceptance criteria, shortlist two or three pinned model versions, pilot them on your own code and validate every candidate with the same CI quality gate.
Teams should also set guardrails and score candidates on correctness, security, maintainability and other criteria.
Experiment finds a behavioral harness made a cheap coding model as reliable as a frontier model at 33% lower cost.
Naresh Jain had coding agents build the same API service with and without a behavioral harness of architectural contracts and deterministic test feedback.
The frontier model passed all 178 acceptance tests in all 10 runs either way, and the harness only raised its token use about 10.5 times and its cost about 7 times.
The cost-optimized model succeeded in only 3 of 10 unharnessed runs but 10 of 10 with the harness.
Even with higher token use, harnessed runs of the smaller model cost $0.273 versus $0.406 for the frontier model, suggesting harnesses are a practical way to get dependable results from smaller models.
Mid-sized and larger companies are building internal Lovable-style platforms so non-engineers can create apps.
Gergely Orosz describes Ramp's Glass, an internal vibe-coding platform built by a four-person team that lets non-engineers create and share complex internal applications.
Users connect internal systems as data sources, and one popular example is a custom CRM built by a marketer with more than 50 fields and filters.
Orosz has since found many mid-sized and larger companies building similar internal tools that rarely become public.
Ramp has now launched Glass externally as an AI workspace product.
Domain modeling lessons from Shipt's commerce platform: few first-class entities, set intersections and typed constraints.
The article describes how Shipt designed its Kit platform for composable commerce.
A key takeaway is to build from a small number of first-class entities that reference each other instead of duplicating data, and to resist adding a new entity for every use case.
Multi-constraint features, such as which locations serve a customer and which categories have eligibility rules, should be treated as intersections of independently evaluated sets.
Regulated product categories should be modeled as distinct types with their own rules, and layered lightweight guards can be used when a fully safe editing workflow cannot fit a deadline.
MCP solved tool connectivity; running it reliably across users, credentials and failures is the next problem.
MCP gave the ecosystem a common interface between models and tools, supported by clients such as Claude Code, Cursor, Codex and VS Code, with Tier 1 SDKs nearing half a billion monthly downloads.
The author, who builds around MCP for coding agents, argues that the protocol standardized faster than the infrastructure around it.
Production involves multiple agents and users, many servers, credentials that must not leak, rate limits, per-task permissions, retries, logging, changing schemas and context limits.
The piece outlines the reliability, security, efficiency and observability layers that are still needed.
Two silent incidents in a solo Android app show mobile reliability is about data between fetch and display.
After 13 years building Android apps, the author built Weather Pal, a Kotlin and Jetpack Compose forecast app that relays all requests through his own gateway with coordinates rounded for privacy.
Two incidents occurred that produced no errors.
First, the OS quietly stopped a WorkManager widget refresh so a user saw stale weather, and second, unauthorized scripts drained the API quota that would have refreshed data.
The lesson is that mobile reliability depends on what happens between fetch and display and on who else is using the pipe you pay for.
A coding agent ignored a retrieved architecture decision, exposing the gap between relevance and authority.
Following an earlier piece on architectural guardrails for AI-generated code, the author describes a test repository where an active decision ruled out PostgreSQL, ORMs and migrations for a CLI app.
The decision was retrieved and placed in the agent's context, yet the agent still proposed PostgreSQL with an ORM.
The failure was not retrieval but a missing applicability signal telling the system that the decision governed the module being edited.
The article separates relevance from authority and guidance from enforcement, arguing that agents need both explicit scope and reproducible checks.
Addy Osmani argues code quality for agent-written code must move from human review into harness constraints.
Republished from Addy Osmani's Elevate blog, the piece notes that reading every change does not scale when agents produce huge volumes of code, so quality checks increasingly have to live in the harness, environment and operating system around the agent.
Osmani calls these constraints quality gates: unit tests, property tests, acceptance tests and other deterministic checks applied to agent proposals.
He still reviews code but is deliberate about where he relies on constraints instead.
His aim is to build loops that can deliver production software reliably at high change volume.
More from Developer · All IT section newsletters · This week