# Test-driven development

Test-driven development (TDD) is a software development process relying on software requirements being converted to test cases before software is fully developed, and tracking all software development by repeatedly testing the software against all test cases. This is as opposed to software being developed first and test cases created later. Programmers also apply the concept to improving and debugging legacy code developed with older techniques. Process Add a test Run all tests. The new test should fail for expected reasons Write the simplest code that passes the new test All tests should now pass Refactor as needed, using tests after each refactor to ensure that functionality is preserved Repeat.

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

## Anthropic says Claude writes and reviews 90% of its team's code. The catch is how it checks the work.

DevFeed: [Anthropic says Claude writes and reviews 90% of its team's code. The catch is how it checks the work.](<https://devfeed.tech/articles/anthropic-says-claude-writes-and-reviews-90-of-its-team-s-code-the-catch-is-how-it-checks-the-work-146429.md>)

Original publisher: [Read original article](<https://thenewstack.io/anthropic-claude-code-verification/>)

Author: Amanda Caswell

Published: 2026-11-20T16:41:28Z

Content type: news

Language: en

Sources: [The New Stack](<https://devfeed.tech/sources/the-new-stack.md>)

Topics: [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [anthropic](<https://devfeed.tech/topics/anthropic.md>), [ui-testing](<https://devfeed.tech/topics/ui-testing.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [browser-automation](<https://devfeed.tech/tags/browser-automation.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [cost](<https://devfeed.tech/tags/cost.md>), [defects](<https://devfeed.tech/tags/defects.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [differential-testing](<https://devfeed.tech/tags/differential-testing.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [false-negative](<https://devfeed.tech/tags/false-negative.md>), [false-positive](<https://devfeed.tech/tags/false-positive.md>), [software-testing](<https://devfeed.tech/tags/software-testing.md>)

### AI overview

Anthropic says Claude produces roughly 90% of the code from the Claude Code team, supported by a verification system that runs inexpensive deterministic checks--builds, linters, and tests--before using model review for questions tests cannot answer. Agents exercise changes in running apps through browser automation, mobile simulators, or local services. To guard against test manipulation, reviewers read rules from the base branch and results apply only to the exact commit examined; failing tests cannot simply be skipped or rerun until they pass. Engineers review evidence and take over after three unsuccessful rounds. Anthropic reports that merged pull requests more than doubled from June to September while the share later reverted fell by over 40%, but does not attribute the change to verification or publish model-review error rates or specific inference costs.

### Source excerpt

Anthropic says Claude writes and reviews roughly 90% of the code produced by the team building Claude Code, and the The post Anthropic says Claude writes and reviews 90% of its team's code. The catch is how it checks the work. appeared first on The New Stack.

## JetBrains Air in GoLand: Build, Review, and Profile Go Code With Agents

DevFeed: [JetBrains Air in GoLand: Build, Review, and Profile Go Code With Agents](<https://devfeed.tech/articles/jetbrains-air-in-goland-build-review-and-profile-go-code-with-agents-146493.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/go/2026/11/20/jetbrains-air-in-goland/>)

Author: Dominika Stankiewicz

Published: 2026-11-20T14:13:09Z

Content type: tutorial

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>)

Topics: [goland](<https://devfeed.tech/topics/goland.md>), [codex](<https://devfeed.tech/topics/codex.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [junie](<https://devfeed.tech/topics/junie.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [air](<https://devfeed.tech/tags/air.md>), [backend](<https://devfeed.tech/tags/backend.md>), [event](<https://devfeed.tech/tags/event.md>), [go](<https://devfeed.tech/tags/go.md>), [goland](<https://devfeed.tech/tags/goland.md>), [handler](<https://devfeed.tech/tags/handler.md>), [jetbrains](<https://devfeed.tech/tags/jetbrains.md>), [jetbrains-air](<https://devfeed.tech/tags/jetbrains-air.md>), [profile](<https://devfeed.tech/tags/profile.md>), [request](<https://devfeed.tech/tags/request.md>), [review](<https://devfeed.tech/tags/review.md>), [services](<https://devfeed.tech/tags/services.md>), [store](<https://devfeed.tech/tags/store.md>), [webhook](<https://devfeed.tech/tags/webhook.md>)

### AI overview

The article demonstrates using JetBrains Air in GoLand 2026.3 to build and verify a signed Go webhook receiver with coding agents. It recommends defining the service requirements first, reviewing agent diffs for security and idempotency issues, and assigning independent follow-up tasks to separate worktrees before combining and checking them with GoLand's HTTP and database tools. Air supports Junie, Codex, Claude Code, and other Agent Client Protocol agents, with session controls for model, effort, and access. The bundled `goland-profiler` skill lets supported agents capture and inspect profiles. In the example, profiling identifies per-request regular-expression compilation in `validateEventID` as the hot path; moving compilation to package initialization yields a reported 4.6x faster benchmark, 59% fewer bytes, and 80% fewer allocations per request, with timing varying by machine.

### Source excerpt

If you've ever built backend services in Go, chances are you've also written a webhook handler or two. They're small and rarely get much attention - that is, until something breaks. A third-party provider sends a signed request, and then you check the signature, store the event, and reply. Sounds like three easy steps, but [...]

## Five Guardrails That Limit the Damage an AI Agent Can Do

DevFeed: [Five Guardrails That Limit the Damage an AI Agent Can Do](<https://devfeed.tech/articles/five-guardrails-that-limit-the-damage-an-ai-agent-can-do-145977.md>)

Original publisher: [Read original article](<https://towardsdatascience.com/five-guardrails-that-limit-the-damage-an-ai-agent-can-do/>)

Author: Thomas Reid

Published: 2026-11-20T12:00:00Z

Content type: tutorial

Language: en

Sources: [Towards Data Science](<https://devfeed.tech/sources/towards-data-science.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Security](<https://devfeed.tech/topics/security.md>), [function calling](<https://devfeed.tech/topics/function-calling.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [arguments](<https://devfeed.tech/tags/arguments.md>), [guardrail](<https://devfeed.tech/tags/guardrail.md>), [guardrails](<https://devfeed.tech/tags/guardrails.md>), [llmops](<https://devfeed.tech/tags/llmops.md>), [pydantic](<https://devfeed.tech/tags/pydantic.md>), [pytest](<https://devfeed.tech/tags/pytest.md>), [python](<https://devfeed.tech/tags/python.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The article's central safeguard is to let Python enforce what an AI agent can do, since prompts alone cannot reliably prevent harmful actions. It treats user questions, model tool calls, and returned data as untrusted, including indirect prompt injection in database notes. The example uses Pydantic models to reject unknown fields and constrain arguments, an allowlisted dispatcher for read tools, read-only SQLite connections with limited query results, and a cap on the agent's turns. A return write stays outside the autonomous tool loop and is saved only after user confirmation; a UUID idempotency key and database uniqueness constraint prevent duplicate requests on retry. Pytest checks the deterministic controls. The example agent ignored Mina's malicious note, but the article cautions that this does not fully mitigate prompt injection; application-enforced limits reduce the damage a bad model decision can cause.

### Source excerpt

AI Agents for Beginners, Part three: strict Pydantic arguments, a tool allowlist, read-only SQLite, a step cap, and confirmed writes, all verified by five pytest tests in 0.68s. The post Five Guardrails That Limit the Damage an AI Agent Can Do appeared first on Towards Data Science.

## 7 Ways AI Agents Fail in Production (and How to Catch Each One)

DevFeed: [7 Ways AI Agents Fail in Production (and How to Catch Each One)](<https://devfeed.tech/articles/7-ways-ai-agents-fail-in-production-and-how-to-catch-each-one-146247.md>)

Original publisher: [Read original article](<https://machinelearningmastery.com/7-ways-ai-agents-fail-in-production-and-how-to-catch-each-one/>)

Author: Nahla Davies

Published: 2026-11-20T11:00:00Z

Content type: article

Language: en

Sources: [MachineLearningMastery.com](<https://devfeed.tech/sources/machinelearningmastery-com.md>)

Topics: [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [ReAct agent Python](<https://devfeed.tech/topics/react-agent-python.md>), [OpenTelemetry](<https://devfeed.tech/topics/opentelemetry.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [Chaos Engineering](<https://devfeed.tech/topics/chaos-engineering.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [agent-evaluation](<https://devfeed.tech/tags/agent-evaluation.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [fail](<https://devfeed.tech/tags/fail.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [production](<https://devfeed.tech/tags/production.md>)

### AI overview

A green tool response does not prove an agent completed its task; verify outcomes in resulting state and external records. The excerpt proposes seven regression checks: strictly validate tool arguments; compare extracted fields and source versions with confirmed ground truth; test whether injected document instructions are proposed and ensure they never execute; deny unauthorized cross-tenant or unapproved actions and assert stored data stays unchanged; retry with a stable operation ID and deduplicate matching requests; restart from persistent checkpoints and assert completion only when an authorized receipt exists; and stop repeated actions when progress stalls, using separate limits for calls, time, spend, and graph execution. Correlate run events under one ID, distinguish proposed, denied, waiting, and complete states, and pair each failing fixture with a passing control. The excerpt notes limits: confidence scores and citations do not establish correctness, in-memory checkpoints are lost on restart, and a timeout may leave an action's outcome unknown.

### Source excerpt

Three events that look alike need separate names.

## A Guide to the System Properties Extension Annotations in JUnit 6.1

DevFeed: [A Guide to the System Properties Extension Annotations in JUnit 6.1](<https://devfeed.tech/articles/a-guide-to-the-system-properties-extension-annotations-in-junit-6-1-145964.md>)

Original publisher: [Read original article](<https://www.baeldung.com/junit-6-system-properties-extension>)

Author: Emanuel Trandafir

Published: 2026-11-19T23:40:23Z

Content type: article

Language: en

Sources: [Baeldung](<https://devfeed.tech/sources/baeldung.md>)

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

Tags: [annotations](<https://devfeed.tech/tags/annotations.md>), [built-in](<https://devfeed.tech/tags/built-in.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [environment-variables](<https://devfeed.tech/tags/environment-variables.md>), [extension](<https://devfeed.tech/tags/extension.md>), [flaky](<https://devfeed.tech/tags/flaky.md>), [flaky-tests](<https://devfeed.tech/tags/flaky-tests.md>), [introduced](<https://devfeed.tech/tags/introduced.md>), [junit](<https://devfeed.tech/tags/junit.md>), [junit-6](<https://devfeed.tech/tags/junit-6.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [properties](<https://devfeed.tech/tags/properties.md>), [restore](<https://devfeed.tech/tags/restore.md>), [set](<https://devfeed.tech/tags/set.md>), [system](<https://devfeed.tech/tags/system.md>), [test](<https://devfeed.tech/tags/test.md>), [testing](<https://devfeed.tech/tags/testing.md>), [testing-junit-junit-6](<https://devfeed.tech/tags/testing-junit-junit-6.md>), [unit-test](<https://devfeed.tech/tags/unit-test.md>)

### AI overview

JUnit 6.1's built-in system properties extension helps prevent test pollution from JVM properties shared across tests. Use @SetSystemProperty and @ClearSystemProperty for known values; they can be repeated, combined, applied at class level, and overridden for a test with a method-level annotation. Use @RestoreSystemProperties when test code changes properties dynamically or the affected keys are unknown; it restores the original state after each test. In parallel runs, these annotations lock against one another, while tests that access properties directly need @ReadsSystemProperty or @WritesSystemProperty for the same protection. Compared with JUnit Pioneer's similarly named annotations, the built-in option avoids an extra dependency when only system properties are needed; Pioneer may suit older JUnit versions. System Stubs supports dynamic stubs and additional APIs such as environment variables and System.out, so it remains useful when those features are needed.

### Source excerpt

Learn about the System Properties Extension annotations introduced in JUnit 6.1, which work together to clear, set, and restore JVM system properties between unit test runs. The post A Guide to the System Properties Extension Annotations in JUnit 6.1 first appeared on Baeldung.

## Build Tool-Calling Parsers in Rust with AI Agents

DevFeed: [Build Tool-Calling Parsers in Rust with AI Agents](<https://devfeed.tech/articles/build-tool-calling-parsers-in-rust-with-ai-agents-143887.md>)

Original publisher: [Read original article](<https://developer.nvidia.com/blog/build-tool-calling-parsers-in-rust-with-ai-agents/>)

Author: Keiven Chang

Published: 2026-11-19T16:30:46Z

Content type: tutorial

Language: en

Sources: [NVIDIA Developer](<https://devfeed.tech/sources/nvidia-developer.md>), [NVIDIA Technical Blog](<https://devfeed.tech/sources/nvidia-technical-blog.md>)

Topics: [function calling](<https://devfeed.tech/topics/function-calling.md>), [rust-ai](<https://devfeed.tech/topics/rust-ai.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [Nemotron](<https://devfeed.tech/topics/nemotron.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [adapter](<https://devfeed.tech/tags/adapter.md>), [adapting](<https://devfeed.tech/tags/adapting.md>), [agentic-ai-generative-ai](<https://devfeed.tech/tags/agentic-ai-generative-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>), [argument](<https://devfeed.tech/tags/argument.md>), [build](<https://devfeed.tech/tags/build.md>), [call](<https://devfeed.tech/tags/call.md>), [can](<https://devfeed.tech/tags/can.md>), [developer-tools-techniques](<https://devfeed.tech/tags/developer-tools-techniques.md>), [dynamo](<https://devfeed.tech/tags/dynamo.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [inference-performance](<https://devfeed.tech/tags/inference-performance.md>), [leak](<https://devfeed.tech/tags/leak.md>), [markup](<https://devfeed.tech/tags/markup.md>), [model](<https://devfeed.tech/tags/model.md>), [rust](<https://devfeed.tech/tags/rust.md>), [tool](<https://devfeed.tech/tags/tool.md>), [tool-calling](<https://devfeed.tech/tags/tool-calling.md>), [turns](<https://devfeed.tech/tags/turns.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Tool-call parsers must separate text, reasoning, and calls while preserving streaming boundaries and avoiding lost data, duplicate calls, or leaked model markup. The article's Rust workflow uses frontend-crates and its shared Conformance Corpus: adapt applicable UNIFIED fixtures, create and human-review GOLDEN expectations against the model specification and related sources, then implement the parser and inspect captured results in the local conformance report. An unavailable tool is reported as generated; the serving layer checks availability, authorization, schema, and policy. Incomplete calls require explicit buffering and end-of-stream recovery rules rather than guessing missing content. CPU fixtures suffice for parser conformance, while end-to-end validation needs Dynamo runtime, discovery services, and model hardware. Further checks should measure speed and memory across input and chunk sizes, verify incremental event delivery and truncation behavior, and test the configured quote-handling policy. Guided decoding may reduce malformed calls but cannot prevent truncation or incorrect tool choices.

### Source excerpt

A tool call can arrive in pieces, an argument can be cut short, or model-specific markup can leak into the answer. A frontend parser turns that output, received...

## Three Records Your Support Team Needs After a Background Job Fails

DevFeed: [Three Records Your Support Team Needs After a Background Job Fails](<https://devfeed.tech/articles/three-records-your-support-team-needs-after-a-background-job-fails-143910.md>)

Original publisher: [Read original article](<https://hackernoon.com/three-records-your-support-team-needs-after-a-background-job-fails?source=rss>)

Author: Khakan Ali

Published: 2026-11-19T14:37:05Z

Content type: tutorial

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Transactions](<https://devfeed.tech/topics/transactions.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [transaction-log](<https://devfeed.tech/topics/transaction-log.md>), [Job](<https://devfeed.tech/topics/job.md>)

Tags: [acceptance](<https://devfeed.tech/tags/acceptance.md>), [background](<https://devfeed.tech/tags/background.md>), [background-jobs](<https://devfeed.tech/tags/background-jobs.md>), [build](<https://devfeed.tech/tags/build.md>), [catalog](<https://devfeed.tech/tags/catalog.md>), [change](<https://devfeed.tech/tags/change.md>), [code](<https://devfeed.tech/tags/code.md>), [commit](<https://devfeed.tech/tags/commit.md>), [complete](<https://devfeed.tech/tags/complete.md>), [crash](<https://devfeed.tech/tags/crash.md>), [crash-recovery](<https://devfeed.tech/tags/crash-recovery.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [customer](<https://devfeed.tech/tags/customer.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [database-transactions](<https://devfeed.tech/tags/database-transactions.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [idempotent-background-jobs](<https://devfeed.tech/tags/idempotent-background-jobs.md>), [idempotent-processing](<https://devfeed.tech/tags/idempotent-processing.md>), [learn](<https://devfeed.tech/tags/learn.md>), [python](<https://devfeed.tech/tags/python.md>), [python-sqlite-importer](<https://devfeed.tech/tags/python-sqlite-importer.md>), [retries](<https://devfeed.tech/tags/retries.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [tests](<https://devfeed.tech/tags/tests.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The local Python/SQLite importer makes a failed job inspectable by saving three records: the accepted import's exact bytes and hash, each row committed with its catalog change in one transaction, and an outcome derived from completed-row counts. Reusing the same import ID and bytes safely skips completed rows in this single-database design; changed bytes under that ID are rejected. Process-exit tests show that a retry completes work after a pre-commit failure, and after a post-commit failure it preserves the committed row without rewriting it, even when acknowledgment was absent. Competing local workers produced exactly two catalog writes for two rows, with SQLite serializing writes and a 15-second lock wait. The example ran locally with Python 3.13.3 and SQLite 3.49.2. It does not establish safety for remote side effects, distributed systems, power loss, or production deployment; an uncertain remote action requires provider idempotency behavior and reconciliation.

### Source excerpt

Learn how to build a crash-recoverable Python and SQLite importer using transactions, idempotent retries, and tests for interrupted background jobs.

## AI Software Factory Building Blocks for 2027

DevFeed: [AI Software Factory Building Blocks for 2027](<https://devfeed.tech/articles/ai-software-factory-building-blocks-for-2027-143902.md>)

Original publisher: [Read original article](<https://hackernoon.com/ai-software-factory-building-blocks-for-2027?source=rss>)

Author: QA.tech

Published: 2026-11-19T12:17:47Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [AI in frontend development](<https://devfeed.tech/topics/ai-in-frontend-development.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [2027](<https://devfeed.tech/tags/2027.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [acceptance](<https://devfeed.tech/tags/acceptance.md>), [addy-osmani](<https://devfeed.tech/tags/addy-osmani.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-software](<https://devfeed.tech/tags/ai-software.md>), [ai-software-building-blocks](<https://devfeed.tech/tags/ai-software-building-blocks.md>), [ai-software-factory](<https://devfeed.tech/tags/ai-software-factory.md>), [ai-testing](<https://devfeed.tech/tags/ai-testing.md>), [autonomous-software-engineerin](<https://devfeed.tech/tags/autonomous-software-engineerin.md>), [autonomy](<https://devfeed.tech/tags/autonomy.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [building](<https://devfeed.tech/tags/building.md>), [can](<https://devfeed.tech/tags/can.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [factory](<https://devfeed.tech/tags/factory.md>), [good-company](<https://devfeed.tech/tags/good-company.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-factory](<https://devfeed.tech/tags/software-factory.md>), [tools](<https://devfeed.tech/tags/tools.md>), [trust](<https://devfeed.tech/tags/trust.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

An AI software factory runs multiple coding agents in parallel on queued work, with automated checks and review gates. Because code generation can scale faster than verification, safe autonomy depends on checking the running product, not just the diff: unit tests check code, review bots inspect changes, and an independent QA agent can exercise user goals on a live app. The excerpt describes verification before a PR through MCP tools in Claude Code, Cursor, or Codex, and PR checks against a preview deployment (or staging after merge), reporting pass, fail, or unable to verify. It recommends previews, running-app checks on every PR, risk-based review gates, and increasing autonomy only as verification capacity allows. Human judgment remains important for regulated domains, legacy systems, and usability decisions; the source favors a light factory for many teams and warns that dark factories can increase comprehension debt.

### Source excerpt

Eight building blocks of an AI software factory, the tools behind them, and why verification determines how much autonomy you can trust.

## Producing Healthy Code with Artificial Intelligence Costs Fewer Tokens

DevFeed: [Producing Healthy Code with Artificial Intelligence Costs Fewer Tokens](<https://devfeed.tech/articles/producing-healthy-code-with-artificial-intelligence-costs-fewer-tokens-143689.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/11/healthy-code-AI-tokens/>)

Author: Ben Linders

Published: 2026-11-19T11:09:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [Code Health](<https://devfeed.tech/topics/code-health.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [clean-code](<https://devfeed.tech/topics/clean-code.md>), [Code Modularity](<https://devfeed.tech/topics/code-modularity.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-development-lifecycle](<https://devfeed.tech/tags/agentic-development-lifecycle.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [ai-cost-optimisation](<https://devfeed.tech/tags/ai-cost-optimisation.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [better](<https://devfeed.tech/tags/better.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [code](<https://devfeed.tech/tags/code.md>), [code-health](<https://devfeed.tech/tags/code-health.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [costs](<https://devfeed.tech/tags/costs.md>), [culture-methods](<https://devfeed.tech/tags/culture-methods.md>), [data](<https://devfeed.tech/tags/data.md>), [development](<https://devfeed.tech/tags/development.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [fewer](<https://devfeed.tech/tags/fewer.md>), [goto-conference](<https://devfeed.tech/tags/goto-conference.md>), [health](<https://devfeed.tech/tags/health.md>), [healthy-code-ai-tokens](<https://devfeed.tech/tags/healthy-code-ai-tokens.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [means](<https://devfeed.tech/tags/means.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [news](<https://devfeed.tech/tags/news.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [speed](<https://devfeed.tech/tags/speed.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [up](<https://devfeed.tech/tags/up.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

The excerpt reports that agentic coding can initially raise velocity, but a study of 1,000+ open-source projects found those gains were erased after two months as code complexity grew. Adam Tornhill argues that healthier code helps AI perform better and use 40%-45% fewer tokens. In the described tests, Claude alone fixed about half of code health issues in lower-health code and correctly refactored only 20% once health improved; giving agents code health data through an MCP raised the reported fix rate to 90%-100%. For refactoring at scale, the interview recommends measuring a baseline, establishing a reliable test safety net, and using iterative feedback based on code health and test results. Safeguards such as linting, coverage, mutation testing, and code health metrics should be automated and exposed through MCP servers or command-line tools. The excerpt says module-level quality automation is largely solved, while design and architecture remain challenges.

### Source excerpt

Agentic AI can speed up velocity, but the gains vanish within months as code complexity grows. Healthy code makes AI perform better and costs fewer tokens. Safeguarding means keeping code health high through agentic refactoring, with an MCP supplying code health data, so AI can maintain the code it generates. By Ben Linders

## What AI-First Engineering Means for the Future of Software Quality

DevFeed: [What AI-First Engineering Means for the Future of Software Quality](<https://devfeed.tech/articles/what-ai-first-engineering-means-for-the-future-of-software-quality-145967.md>)

Original publisher: [Read original article](<https://testgrid.io/blog/ai-first-engineering/>)

Author: Ankita Nandi

Published: 2026-11-19T10:55:22Z

Content type: article

Language: en

Sources: [TestGrid](<https://devfeed.tech/sources/testgrid-blog.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [engineering-leadership](<https://devfeed.tech/topics/engineering-leadership.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-generated-tests](<https://devfeed.tech/tags/ai-generated-tests.md>), [ai-testing](<https://devfeed.tech/tags/ai-testing.md>), [ai-workflow](<https://devfeed.tech/tags/ai-workflow.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [automation](<https://devfeed.tech/tags/automation.md>), [bank](<https://devfeed.tech/tags/bank.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [billing](<https://devfeed.tech/tags/billing.md>), [block](<https://devfeed.tech/tags/block.md>), [browser](<https://devfeed.tech/tags/browser.md>), [browsers](<https://devfeed.tech/tags/browsers.md>), [credit-card](<https://devfeed.tech/tags/credit-card.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [quality](<https://devfeed.tech/tags/quality.md>), [rules](<https://devfeed.tech/tags/rules.md>), [software](<https://devfeed.tech/tags/software.md>), [system](<https://devfeed.tech/tags/system.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

AI-first workflows can accelerate software delivery, but when an agent derives code, tests and documentation from the same incomplete requirement, they can all reinforce one mistaken assumption. The excerpt distinguishes tests that confirm behavior inferred from buggy code from tests that correctly enforce a flawed or underspecified business rule; either can leave a green build that fails users. It recommends agreeing on expected behavior and edge-case examples before implementation, having an accountable domain expert approve them, and generating business-rule tests from those approved expectations. Validate AI-generated tests by planting known bugs. For high-risk changes, add independent security review, hands-on human testing and sign-off. Use execution evidence such as video, screenshots, logs and network traffic to investigate failures, and measure customer bugs, pre-release risks and diagnosis time rather than test counts alone. The excerpt also calls for junior engineers to practice questioning requirements and explaining conclusions. Its example is hypothetical, and the overview reflects the supplied excerpt.

### Source excerpt

Let's say you oversee a bank's credit-card billing-error system. Your product team gives an AI agent a requirement: "Accept written billing-error notices within 60 days." The agent implements the rule, generates 40 tests, and reports that every test passes. But it has started the clock on the transaction date. Under US federal billing-error rules, the [...]

## Checking Retry Transparency in Agent Tools

DevFeed: [Checking Retry Transparency in Agent Tools](<https://devfeed.tech/articles/checking-retry-transparency-in-agent-tools-142168.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23307>)

Author: Jiapeng Li (Microsoft)

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

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

Tags: [absorption](<https://devfeed.tech/tags/absorption.md>), [admission](<https://devfeed.tech/tags/admission.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-tools](<https://devfeed.tech/tags/agent-tools.md>), [annotation](<https://devfeed.tech/tags/annotation.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [boundary](<https://devfeed.tech/tags/boundary.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [browser](<https://devfeed.tech/tags/browser.md>), [completion](<https://devfeed.tech/tags/completion.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [effect](<https://devfeed.tech/tags/effect.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [file](<https://devfeed.tech/tags/file.md>), [git](<https://devfeed.tech/tags/git.md>), [graph](<https://devfeed.tech/tags/graph.md>), [identity](<https://devfeed.tech/tags/identity.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [retry](<https://devfeed.tech/tags/retry.md>), [transparency](<https://devfeed.tech/tags/transparency.md>)

### AI overview

A successful retry can still leave an earlier attempt able to overwrite a later acknowledged update, so a tool's local idempotence claim may not guarantee recovery. The prototype tests manually constructed, source-backed effect contracts at two levels: atomic retry absorption and bounded interleavings of successful-attempt microsteps. It produces model witnesses, conditional admission decisions, and explicit uncertainty when completion boundaries are unjustified. In 27 missing-reply checks, its selective rule completed six justified workflows without acknowledged goal violations; strict coalescing completed none, while blind retry completed nine with three violations. An intent-aware Porcupine specification agreed with all 156 complete-history oracles. The evaluation covers a purposive frame of six MCP components from four repositories, with one backend unavailable; the authors caution these mechanism-selected tests do not estimate defect prevalence or introduce a new linearizability algorithm.

### Source excerpt

arXiv:2611.23307v1 Announce Type: new Abstract: A successful retry does not necessarily put the earlier attempt behind it. An old write may still overwrite a later acknowledged update; a partially executed file write may even empty a file after the retry has returned successfully. We study how to test the recovery guarantee behind an agent tool's local idempotence claim. Our prototype takes manually constructed, source-backed effect contracts and checks them at two levels: atomic retry-absorption obligations and bounded interleavings of successful-attempt microsteps. It emits model witnesses, conditional admission decisions, and explicit uncertainty when a completion boundary cannot be justified. The evaluation preserves a locally frozen purposive frame of 6 MCP components from 4 repositories; selected paths in 5 execute on the study machine and one backend remains unavailable. Real tests include file, graph, Git-index, document-update and browser bindings, together with a native Qdrant development matrix. In 27 missing-reply checks, the selective rule completes six justified workflows without an acknowledged goal violation, whereas strict coalescing completes none and blind retry completes nine with three violations. An intent-aware Porcupine specification independently agrees with all 156 complete-history oracles. These are mechanism-selected tests, not defect-prevalence estimates or a new linearizability algorithm. The contribution is an executable recovery-contract workflow that makes effect granularity, logical identity and completion assumptions testable rather than inheriting them from a tool annotation.

## torchtest2: One-Call Sanity Checks for PyTorch Models,Evaluated on Real and Unseen Architectures

DevFeed: [torchtest2: One-Call Sanity Checks for PyTorch Models,Evaluated on Real and Unseen Architectures](<https://devfeed.tech/articles/torchtest2-one-call-sanity-checks-for-pytorch-models-evaluated-on-real-and-unseen-architectures-142145.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23273>)

Author: Grzegorz Gwardys

Published: 2026-11-19T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [PyTorch](<https://devfeed.tech/topics/pytorch.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Transformers](<https://devfeed.tech/topics/transformers.md>), [timm](<https://devfeed.tech/topics/timm.md>)

Tags: [17](<https://devfeed.tech/tags/17.md>), [3](<https://devfeed.tech/tags/3.md>), [78](<https://devfeed.tech/tags/78.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [after](<https://devfeed.tech/tags/after.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [approach](<https://devfeed.tech/tags/approach.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [attention](<https://devfeed.tech/tags/attention.md>), [batch](<https://devfeed.tech/tags/batch.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bootstrap](<https://devfeed.tech/tags/bootstrap.md>), [call](<https://devfeed.tech/tags/call.md>), [cs-cv](<https://devfeed.tech/tags/cs-cv.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [models](<https://devfeed.tech/tags/models.md>), [one](<https://devfeed.tech/tags/one.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>)

### AI overview

torchtest2 runs 18 PyTorch sanity checks on one batch with a single call, restores touched state, and uses plugins to adapt to model families. On 191 models from unseen architecture families, it detected 78% of injected bugs (95% CI 75-80%), compared with 40% for the original torchtest checks and 48% for a training monitor. It also found a batch-coupling bug in timm's GCViT, while real models revealed false alarms missed by the tool's tests and random architectures. Its reach is limited: only 3 of 28 reproduced Stack Overflow bugs and 3 of 18 TrainCheck silent errors were detectable by a pre-training tester. A median check took 1.0 second.

### Source excerpt

arXiv:2611.23273v1 Announce Type: new Abstract: Many bugs in deep learning code are silent: a layer that is never called, an optimizer created before the classification head was replaced, a recurrent layer that treats the batch as time, or an ignored attention mask. The code runs, the loss decreases somewhat, and the defect surfaces, if ever, after days of GPU time. We present torchtest2, an open-source library that runs 18 sanity checks on a single batch with one call, restores the PyTorch state it touches, and adapts to model families through plugins. We evaluate it by mutation analysis with 17 classes of silent bugs on 103 models from torchvision, timm and Hugging Face transformers, on 600 random architectures and on 20 hand-written realistic bugs, against the checks of the original torchtest, overfitting a single batch, a smoke test and a training monitor in the style of AUTOTRAINER and DeepDiagnosis. Every mutant is compared with its healthy counterpart, and intervals come from a bootstrap over models. After freezing the tool, we ran it on 191 models of architecture families it had never seen: counting, for every tool alike, a failing report where the healthy model's report does not fail, it detected 78% of the injected bugs (95% CI 75-80), against 40% for the original torchtest checks and 48% for the training monitor. On real models its batch-independence check found a bug in timm's GCViT that couples the images of a batch. Real models also exposed false alarms that neither the tool's own test suite nor random architectures had revealed. Two independent collections of real silent bugs mark the limits of the approach: only 3 of 28 reproduced PyTorch bugs from Stack Overflow and 3 of the 18 silent training errors released with TrainCheck are within reach of a pre-training model tester. A median check takes 1.0 s. We release the library, the benchmark and all raw results.

## RefinementGuard: Counterexample-Directed Semantic Qualification for Hidden Agent-Tool Execution

DevFeed: [RefinementGuard: Counterexample-Directed Semantic Qualification for Hidden Agent-Tool Execution](<https://devfeed.tech/articles/refinementguard-counterexample-directed-semantic-qualification-for-hidden-agent-tool-execution-142188.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23611>)

Author: Adhyayan Veer Singh, Fanjiang Ye, Yuke Wang

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [admission](<https://devfeed.tech/tags/admission.md>), [agent](<https://devfeed.tech/tags/agent.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [effectful](<https://devfeed.tech/tags/effectful.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fail](<https://devfeed.tech/tags/fail.md>), [graph](<https://devfeed.tech/tags/graph.md>), [hidden](<https://devfeed.tech/tags/hidden.md>), [independent](<https://devfeed.tech/tags/independent.md>), [latency](<https://devfeed.tech/tags/latency.md>), [localization](<https://devfeed.tech/tags/localization.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [patch](<https://devfeed.tech/tags/patch.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [tool](<https://devfeed.tech/tags/tool.md>), [tool-execution](<https://devfeed.tech/tags/tool-execution.md>), [translation](<https://devfeed.tech/tags/translation.md>)

### AI overview

RefinementGuard qualifies hidden, effectful agent-tool execution by comparing a candidate parallel graph with an independent reference on isolated state, using explicit obligations for the parent operation and fail-closed, artifact-bound admission. In controlled repository evaluations, obligation-based validation rejected 49 of 100 activated non-equivalent faults and accepted all 60 valid variants; exact equality rejected all faults but also all valid variants. The 51 residual misses point to specification gaps. On a disjoint held-out split, results cover localization only: B3 rejected 38 of 56 localization defects, while 21 patch mutants failed structurally. Under controlled asynchronous delays, guarded localization had a 4.50x lower median latency than serial execution and exposed 74.3% less parent-visible context. Patch validation had no demonstrated speedup, and zero-delay runs showed overhead.

### Source excerpt

arXiv:2611.23611v1 Announce Type: cross Abstract: Tool runtimes can lower an agent-selected operation into a hidden parallel graph, reducing latency and context while risking semantic mistranslation. We introduce RefinementGuard: translation validation for hidden, effectful agent-tool lowerings, coupled to artifact-bound, fail-closed runtime admission. Qualification compares a candidate graph with an independent reference on isolated state using explicit parent-operation obligations. We evaluate two repository-level contracts, bug localization and patch validation, on controlled repositories. Among 100 activated, non-equivalent development/qualification faults adjudicated by one human, parent-semantic validation rejects 49/100 (operator-cluster bootstrap 95% CI [33.7%, 64.8%]). The objective is selective admission, not maximum mutation rejection: exact equality rejects 100/100 faults but also all 60 valid variants, whereas obligation-based validation accepts 60/60; its 51 residual misses identify concrete specification gaps. On a frozen disjoint input split, the held-out B2-B3 result is localization-only because 21 patch mutants fail structurally; B3 rejects 38/56 localization defects. In a controlled asynchronous-delay regime, the localization serial/guarded median-latency ratio is 4.50x, and hidden execution exposes 74.3% less parent-visible context than visible execution. Patch validation shows no demonstrated speedup; zero-delay runs expose overhead. End-to-end qualification thus detects lower-layer misses while preserving localization's parallelism.

## Decided or Open? Comparing Program Repair Techniques When Patch Correctness Is Unknown

DevFeed: [Decided or Open? Comparing Program Repair Techniques When Patch Correctness Is Unknown](<https://devfeed.tech/articles/decided-or-open-comparing-program-repair-techniques-when-patch-correctness-is-unknown-142156.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23287>)

Author: Sadnan Nafis

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

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

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [comparisons](<https://devfeed.tech/tags/comparisons.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [models](<https://devfeed.tech/tags/models.md>), [patch](<https://devfeed.tech/tags/patch.md>), [patches](<https://devfeed.tech/tags/patches.md>), [program](<https://devfeed.tech/tags/program.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [repair](<https://devfeed.tech/tags/repair.md>), [settings](<https://devfeed.tech/tags/settings.md>), [study](<https://devfeed.tech/tags/study.md>), [techniques](<https://devfeed.tech/tags/techniques.md>), [test](<https://devfeed.tech/tags/test.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The paper proposes labeling APR comparisons "decided" or "open" when patch correctness is partly unknown. For two techniques selecting one patch per bug, it calculates the full possible range of their success-rate difference; a comparison is decided if the range excludes zero. Since testing can establish that a patch is wrong but cannot prove it correct, the method can identify open comparisons that further testing cannot settle. Across eight settings, including 55,466 candidate patches for Defects4J bugs, existing labels decided 12 of 16 learned-selector comparisons, and additional evidence decided all 16; all eight predictions in a preregistered campaign held. Archived test reliability also differed by model: developer-fix copies were recorded as failing in 33.5% of GPT-4 cases versus 2.5% for RepairLLaMA. The excerpt does not detail the additional evidence types.

### Source excerpt

arXiv:2611.23287v1 Announce Type: new Abstract: Comparisons of automated program repair (APR) techniques depend on knowing which patches are correct, but many patches are never checked and some archived test results are wrong. We propose reporting each comparison as decided or open. For two techniques that each pick one patch per bug, we compute the full range of the difference in their success rates over every possible value of the unknown labels, and we call the comparison decided when that range excludes zero. Because a test can only show that a patch is wrong, more testing can move this range in one direction only. This lets us tell, before any test runs, which open comparisons testing could never settle. We study eight settings, including 55,466 candidate patches for Defects4J bugs. The labels already in the archive decide 12 of 16 comparisons between a learned patch selector and its baselines, and adding further evidence decides all 16. In a campaign whose predictions we published in advance, all eight predictions held. We also show that copies of the developer's fix, which must pass, are recorded as failing for 33.5% of GPT-4's copies but for only 2.5% of the RepairLLaMA model's, so the reliability of archived test results differs between models. With these checks, researchers can see which comparisons need more evidence and which kind of evidence can help.

## RoboDx: Repair and Diagnosis of Faults in Robot Software

DevFeed: [RoboDx: Repair and Diagnosis of Faults in Robot Software](<https://devfeed.tech/articles/robodx-repair-and-diagnosis-of-faults-in-robot-software-142197.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23816>)

Author: Soham Dan

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Robot Navigation](<https://devfeed.tech/topics/robot-navigation.md>), [patches](<https://devfeed.tech/topics/patches.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [bug-fix](<https://devfeed.tech/tags/bug-fix.md>), [claude-opus-5-5](<https://devfeed.tech/tags/claude-opus-5-5.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cs-ro](<https://devfeed.tech/tags/cs-ro.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [diagnosis](<https://devfeed.tech/tags/diagnosis.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [opus-5-5](<https://devfeed.tech/tags/opus-5-5.md>), [repair](<https://devfeed.tech/tags/repair.md>), [robot](<https://devfeed.tech/tags/robot.md>), [simulator](<https://devfeed.tech/tags/simulator.md>), [software](<https://devfeed.tech/tags/software.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

RoboDx evaluates whether agents can repair and diagnose faults in simulated robot navigation software. Its hidden verifier checks driving in unseen scenarios, but a verified repair does not guarantee every fault was removed: on 50 two-fault tasks, only 17 of Claude Opus 5.5's 49 verified repairs removed both injected edits, often leaving undocumented configuration constants. Without code, Opus identified both faults on 10 of those 50 tasks. In diagnosis, four models named the cause on at most 38 of 94 tasks using robot measurements; access to simulator outputs for each hypothesis yielded near-universal correctness, while models' own output predictions showed no detectable gain. Results on 97 real bug-fix pull requests did not order the three stronger models, and Haiku 5.5 scored lowest.

### Source excerpt

arXiv:2611.23816v1 Announce Type: cross Abstract: A patch to a robot's navigation software can pass every unit test and still drive the robot off its path. Checking how the repaired robot drives catches such patches. It does not show that the agent found everything that was wrong. We introduce RoboDx, a generator of repair tasks for simulated robot navigation software with known injected faults. A hidden verifier marks a repair as verified only if the robot then drives correctly in hidden scenarios, which the agent never sees. A second track hides the code and asks the agent to pick the cause from a list of hypotheses. A task with two faults can contain a quiet fault, a fault that makes no hidden scenario fail unless the other fault is also present. On our set of 100 tasks, RoboDx-Hard-100, almost every repair by Claude Opus 5.5 with standard coding tools is verified. We analyse 94 of the tasks, 44 with one fault and 50 with two. On the 50 two-fault tasks, only 17 of Opus's 49 verified repairs remove both injected edits. Most faults left behind are configuration constants whose correct value the task's documentation does not state. Opus names both faults on 10/50 of these tasks when it cannot see the code. We then give four current models the same measurements of each faulty robot, picked so that, in the simulator, only the true cause produces all of them. The models name the cause on at most 38 of 94 tasks. They are right on almost all when they also get the simulator's output for every hypothesis. Their own predictions of that output give no detectable gain. On 97 tasks from real bug-fix pull requests, Claude Haiku 5.5, the weakest model on the generated tasks, scores lowest, and the other three models are not ordered.

## From Brisbane to the rOpenSci Community: Ten Years of Open Research Software

DevFeed: [From Brisbane to the rOpenSci Community: Ten Years of Open Research Software](<https://devfeed.tech/articles/from-brisbane-to-the-ropensci-community-ten-years-of-open-research-software-144781.md>)

Original publisher: [Read original article](<https://ropensci.org/blog/2026/11/19/brisbane-to-community/>)

Author: rOpenSci

Published: 2026-11-19T00:00:00Z

Content type: article

Language: en

Sources: [rOpenSci](<https://devfeed.tech/sources/ropensci-open-tools-for-open-science.md>)

Topics: [Open Source](<https://devfeed.tech/topics/open-source.md>), [experience report](<https://devfeed.tech/topics/experience-report.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [2016](<https://devfeed.tech/tags/2016.md>), [about](<https://devfeed.tech/tags/about.md>), [also](<https://devfeed.tech/tags/also.md>), [australia](<https://devfeed.tech/tags/australia.md>), [but](<https://devfeed.tech/tags/but.md>), [code](<https://devfeed.tech/tags/code.md>), [community](<https://devfeed.tech/tags/community.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [connect](<https://devfeed.tech/tags/connect.md>), [contributed](<https://devfeed.tech/tags/contributed.md>), [data](<https://devfeed.tech/tags/data.md>), [developing](<https://devfeed.tech/tags/developing.md>), [doing](<https://devfeed.tech/tags/doing.md>), [event](<https://devfeed.tech/tags/event.md>), [experience](<https://devfeed.tech/tags/experience.md>), [first](<https://devfeed.tech/tags/first.md>), [open](<https://devfeed.tech/tags/open.md>), [research](<https://devfeed.tech/tags/research.md>), [ropensci](<https://devfeed.tech/tags/ropensci.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

The author's ten-year rOpenSci story shows how a welcoming, hands-on research software community can help newcomers contribute and grow. At the 2016 Brisbane Unconf, they improved code for downloading Australian weather grids and wrote a vignette; subsequent software peer review helped strengthen GSODR's focus, reproducibility and robustness, and taught them the importance of documentation, testing and ongoing maintenance. They later developed weather and climate packages, learned to test remote APIs with {vcr}, reviewed packages and became an editor. The author says reviewing others' code also improved their own practice. Lessons from rOpenSci informed Open Plant Pathology, which the founders wound down in 2025. They encourage contributions at many levels, from bug reports and documentation to package reviews, and argue that sustained community relationships and constructive feedback matter alongside the software. They note that rOpenSci must adapt to changing tools and growing editorial demands while keeping peer review useful and welcoming.

### Source excerpt

With rOpenSci turning 15 this year, it's hard to believe that I've been part of it for 10 of those years. My involvement started in Brisbane in 2016, at the first Australian rOpenSci Unconference. I'd known about rOpenSci and its work for some time before then. When rOpenSci was founded in 2011, I'd just moved from the US to the Philippines for work. During the five years I lived and worked there, I became familiar with its packages and the people behind them. I was interested in what rOpenSci was doing, but wasn't sure how I might get involved. I did recognise the value of being part of the R community, though, and joined the Manila R User Group. Brisbane 2016: just the beginning I moved to Australia for work in January 2016 and, as luck would have it, was living close enough to Brisbane to attend the rOpenSci Unconf in April. The event was organised by a group of researchers at QUT, including Nick Tierney, Miles McBain and Jessie Roberts. As it happened, my first R package, {GSODR}, had just been accepted onto CRAN. That was the fact I shared when introducing myself to the other attendees. I was an experienced researcher and R user, but still very much a newcomer to developing and publishing R packages. I was nervous about attending. I was new to Australia and had never been to an event quite like it. But the chance to bring Australian R users together to work on practical research problems was exciting, and I soon settled in. The format was very hands-on. We shared unfinished ideas, learned from one another and built things together. I found this a great way to learn, and it helped me gain confidence. I was one of the few attendees with experience working with geospatial data and a particular interest in weather data, which led me to connect with A/Prof Ivan Hanigan. Ivan had some R code for downloading AWAP grids, AWAP_GRIDS, and I was able to help improve it. I also contributed a vignette describing how to work with Australian weather data, which went on to inf

## AI Governance in EdTech: 6 Things to Get Right Before Launch

DevFeed: [AI Governance in EdTech: 6 Things to Get Right Before Launch](<https://devfeed.tech/articles/ai-governance-in-edtech-6-things-to-get-right-before-launch-141075.md>)

Original publisher: [Read original article](<https://8thlight.com/insights/choosing-ai-development-partner-edtech>)

Author: 8th Light

Published: 2026-11-18T06:00:00Z

Content type: tutorial

Language: en

Sources: [8th Light](<https://devfeed.tech/sources/8th-light.md>), [8th Light Insights](<https://devfeed.tech/sources/8th-light-insights.md>)

Topics: [ai-governance](<https://devfeed.tech/topics/ai-governance.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [data ownership](<https://devfeed.tech/topics/data-ownership.md>)

Tags: [access-controls](<https://devfeed.tech/tags/access-controls.md>), [accountability](<https://devfeed.tech/tags/accountability.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-and-emerging-tech](<https://devfeed.tech/tags/ai-and-emerging-tech.md>), [ai-governance](<https://devfeed.tech/tags/ai-governance.md>), [ai-in-education](<https://devfeed.tech/tags/ai-in-education.md>), [data](<https://devfeed.tech/tags/data.md>), [edtech](<https://devfeed.tech/tags/edtech.md>), [governance](<https://devfeed.tech/tags/governance.md>), [launch](<https://devfeed.tech/tags/launch.md>)

### AI overview

AI governance for EdTech is implemented through software controls that protect student data, validate outputs, preserve accountability, and set human oversight according to the stakes of a feature. The article recommends six practices: minimize data and define retention; enforce role-based permissions before information reaches the model; check responses for safety and age appropriateness, with fallback or escalation; keep restricted, limited audit records; route high-risk decisions or concerns to people; and monitor behavior after launch, feeding findings into testing. It identifies FERPA, COPPA, state student privacy laws, and district contracts as requirements that vary by product and use. Its AllCampus example describes Ally using platform data, scripted evaluations, reviewable conversations, safeguards, and human advisors; the article notes adult learners have different regulatory requirements from K-12. This is general engineering guidance, not legal advice.

### Source excerpt

Getting a school district to trust it with student data is another. Who can access student data? Here's what AI governance means for EdTech, the six...

## BugGen 2.0: Rethinking the Roles of LLMs for Scalable RTL Bug Synthesis

DevFeed: [BugGen 2.0: Rethinking the Roles of LLMs for Scalable RTL Bug Synthesis](<https://devfeed.tech/articles/buggen-2-0-rethinking-the-roles-of-llms-for-scalable-rtl-bug-synthesis-139616.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23091>)

Author: Minh Luu, Michael Quinn, Aakash Tyagi, David Houngninou, Jiang Hu

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [acceptance](<https://devfeed.tech/tags/acceptance.md>), [aes](<https://devfeed.tech/tags/aes.md>), [after](<https://devfeed.tech/tags/after.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [also](<https://devfeed.tech/tags/also.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [bug](<https://devfeed.tech/tags/bug.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [can](<https://devfeed.tech/tags/can.md>), [capability](<https://devfeed.tech/tags/capability.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [llms](<https://devfeed.tech/tags/llms.md>), [roles](<https://devfeed.tech/tags/roles.md>), [rtl](<https://devfeed.tech/tags/rtl.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>)

### AI overview

BugGen 2.0 assigns structural analysis, mutation target selection, and validation to deterministic algorithms, leaving the LLM to perform localized semantic RTL rewrites. Across four OpenTitan IP blocks and FabScalar with three LLMs, it met every requested quota of compilable scenarios causing at least two test failures, with 14-16 of 16 mutation types represented. In completed same-model comparisons, it used 6.8-15.4x fewer tokens than BugGen 1.0 and 1.5-7.9x fewer than Firefly. To expand datasets, it also generates variants at accepted bug locations and simulates only a subset: this skipped 63.6% of AES and 33.9% of FabScalar variant simulations. Full simulation accepted 77.7% of AES and 95.2% of FabScalar variants; the reported estimation error was 1.09% on the directly comparable FabScalar set. These findings are from the abstract.

### Source excerpt

arXiv:2611.23091v1 Announce Type: new Abstract: AI-assisted RTL localization and debugging need ground-truth bug datasets with known locations and observable failures, while testbench grading uses injected bugs to measure detection capability. Creating such datasets at scale remains a major EDA challenge. BugGen 1.0 shows that Large Language Models (LLMs) can generate context-aware RTL mutations. Still, it relies on the model for both choosing where to mutate and generating the edit, which increases inference costs and can lead to invalid choices. BugGen 2.0 changes this division of labor. Deterministic algorithms handle structural analysis, target selection, and validation, while the LLM focuses on localized semantic rewriting. Across four OpenTitan IP blocks and FabScalar with three LLMs, BugGen 2.0 reaches every requested quota of compilable bug scenarios that cause at least two test failures, with 14-16 of 16 configured mutation types represented. In completed same-model comparisons, it reduces token use by 6.8x-15.4x relative to BugGen 1.0 and 1.5x-7.9x relative to Firefly. BugGen 2.0 also expands the dataset without simulating every new bug. After finding accepted scenarios with observable failures, it generates alternative mutations at the same locations, simulates only a subset, and estimates acceptance for the rest. This skips 63.6% of AES and 33.9% of FabScalar variant simulations. Full simulation finds that 77.7% of AES variants and 95.2% of FabScalar variants are accepted, with a 1.09% estimation error on the directly comparable FabScalar set. These results show that focusing LLMs on semantic rewriting lowers inference and simulation cost while improving consistency across models and designs.

## Stochastic Modeling of the Mean Time Between Software Failures: A review

DevFeed: [Stochastic Modeling of the Mean Time Between Software Failures: A review](<https://devfeed.tech/articles/stochastic-modeling-of-the-mean-time-between-software-failures-a-review-139579.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21619>)

Author: Gabriel Pena, Veronica Moreno, Nestor Barraza

Published: 2026-11-18T05:00:00Z

Content type: comparison

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Software Process](<https://devfeed.tech/topics/software-process.md>), [Agile](<https://devfeed.tech/topics/agile.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agile](<https://devfeed.tech/tags/agile.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [failures](<https://devfeed.tech/tags/failures.md>), [methodologies](<https://devfeed.tech/tags/methodologies.md>), [model](<https://devfeed.tech/tags/model.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [models](<https://devfeed.tech/tags/models.md>), [performance](<https://devfeed.tech/tags/performance.md>), [process](<https://devfeed.tech/tags/process.md>), [processes](<https://devfeed.tech/tags/processes.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [review](<https://devfeed.tech/tags/review.md>), [scrum](<https://devfeed.tech/tags/scrum.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [stat-ap](<https://devfeed.tech/tags/stat-ap.md>), [testing](<https://devfeed.tech/tags/testing.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The review compares how established non-homogeneous Poisson process models and a recently proposed contagion model derive mean time between software failures, with attention to Agile projects where testing and debugging are iterative. In the Poisson models, failure rate varies with time; in the contagion model, it also depends on the number of failures already detected. The authors place these models within the broader class of non-homogeneous birth processes and outline a general theory for expected times to failure and between failures. The excerpt states the review's evaluation focus but gives no comparative performance results.

### Source excerpt

arXiv:2611.21619v1 Announce Type: new Abstract: A review of several models for the software failure detection stochastic process is per- formed. We focus on how the Mean Time Between Failures is obtained from those models and present a comparative study. The models considered involve some of the well known based on non- homogeneous Poisson processes and a recently proposed model based on contagion. Our main target is to evaluate the models performance when they are applied to modern software projects developed under Agile methodologies. Recently developed Software Engineering practices (TDD, Scrum, etc.), propose an iterative procedure be- tween development, testing and debugging, introducing this way, particular challenges to Software Reliability modeling. As opposed to the non-homogeneous Poisson processes, the failure rate of the contagion model depends not just on time but also on the number of previously detected failures. All the considered models are particular cases of non- homogeneous Birth Processes, a general fundamental theory on how to obtain time to failure and time between failures expectations is also shown.

## FCP: Formal Context Protocol for Verifying LLM-Generated Artifacts

DevFeed: [FCP: Formal Context Protocol for Verifying LLM-Generated Artifacts](<https://devfeed.tech/articles/fcp-formal-context-protocol-for-verifying-llm-generated-artifacts-139894.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21679>)

Author: Shashank

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [adapters](<https://devfeed.tech/tags/adapters.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [all](<https://devfeed.tech/tags/all.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [assertions](<https://devfeed.tech/tags/assertions.md>), [code](<https://devfeed.tech/tags/code.md>), [concrete](<https://devfeed.tech/tags/concrete.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [decision](<https://devfeed.tech/tags/decision.md>), [designs](<https://devfeed.tech/tags/designs.md>), [engines](<https://devfeed.tech/tags/engines.md>), [formal](<https://devfeed.tech/tags/formal.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [language](<https://devfeed.tech/tags/language.md>), [language-model](<https://devfeed.tech/tags/language-model.md>), [llm](<https://devfeed.tech/tags/llm.md>), [protocol](<https://devfeed.tech/tags/protocol.md>)

### AI overview

FCP checks AI-generated artifacts against the request rather than relying on tests written by the same model. It separates conformance--whether an artifact satisfies a formalized requirement, checked by model checkers or SMT solvers--from fidelity: whether that formalization captures the prose, which cannot be decided mechanically but can be challenged with a concrete counterexample. The protocol turns eight ways proofs can falsely certify requirements into mechanical checks and surfaces unresolved interpretation questions for the request's author. Its adapters apply the same engines to hardware, text, agents, and code. In the reported evaluations, AI-written assertions certified 23% of violated requirements across four hardware designs, while FCP certified none. On ten code tasks, three models' code passed its own tests yet violated the request each time; trusting those tests certified all 33 violations, while FCP certified three.

### Source excerpt

arXiv:2611.21679v1 Announce Type: cross Abstract: When a language model writes both an artifact and the tests meant to check it, a passing test is weak evidence: one misreading of the request yields a faulty artifact and a check that accepts it. We present the Formal Context Protocol (FCP), which checks AI-generated artifacts against the request itself. FCP separates conformance (does the artifact satisfy a formal reading of a requirement?), which model checkers and SMT solvers decide, from fidelity (does the reading mean what the prose means?), which has no decision procedure but is refutable by a concrete witness. Eight ways a proof can falsely certify a requirement each become a mechanical check that returns a witness, and what no machine can settle becomes concrete questions for the request's author. Adapters place hardware, text, agents and code on the same engines. On four hardware designs, trusting AI-written assertions certified 23% of violated requirements, and FCP certified none. On ten code tasks, code from three language models passed its own tests and violated the request every time. Trusting the tests certified all 33 violations, and FCP certified three. Agreement among models, readings or tests did not imply correctness.

## ESPHome 2026.11.0: Lighter builds and tougher updates

DevFeed: [ESPHome 2026.11.0: Lighter builds and tougher updates](<https://devfeed.tech/articles/esphome-2026-11-0-lighter-builds-and-tougher-updates-141073.md>)

Original publisher: [Read original article](<https://esphome.io/blog/2026/11/18/esphome-2026-11/>)

Author: Jesse Hills

Published: 2026-11-18T00:00:00Z

Content type: release

Language: en

Sources: [ESPHome](<https://devfeed.tech/sources/esphome-smart-home-made-simple-blog.md>)

Topics: [esphome](<https://devfeed.tech/topics/esphome.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [components](<https://devfeed.tech/tags/components.md>), [esphome](<https://devfeed.tech/tags/esphome.md>), [lighter](<https://devfeed.tech/tags/lighter.md>), [ota](<https://devfeed.tech/tags/ota.md>), [ram](<https://devfeed.tech/tags/ram.md>), [releases](<https://devfeed.tech/tags/releases.md>), [udp](<https://devfeed.tech/tags/udp.md>), [updates](<https://devfeed.tech/tags/updates.md>), [uploads](<https://devfeed.tech/tags/uploads.md>)

### AI overview

ESPHome 2026.11.0 reduces memory use across platforms, with constants moved to flash and automation control flow compiled as C++; a sample configuration saves 1,632 bytes of RAM on ESP8266 and ESP32 IDF. Native OTA now switches to UDP when a lossy link makes TCP uploads fail, while HTTP actions run asynchronously, so scripts may need queued or parallel mode to handle repeated triggers. The release adds more than 30 components and networking features, including captive-portal setup and experimental ESP32 OpenThread border routing. Before upgrading, check configuration changes: sub-devices now require `relation`, ESP-IDF 5.1 is the minimum, and several options and behaviors changed. The notes also list platform-specific fixes and migration steps for affected setups.

### Source excerpt

ESPHome 2026.11.0 trims RAM across every platform, compiles automations to plain C++, falls back to UDP on lossy OTA uploads and adds over thirty new components.

## GitLab Transcend Hackathon: Meet the 'Life After Code' winners

DevFeed: [GitLab Transcend Hackathon: Meet the 'Life After Code' winners](<https://devfeed.tech/articles/gitlab-transcend-hackathon-meet-the-life-after-code-winners-142002.md>)

Original publisher: [Read original article](<https://about.gitlab.com/blog/gitlab-transcend-hackathon-life-after-code/>)

Author: Missy Davies

Published: 2026-11-18T00:00:00Z

Content type: news

Language: en

Sources: [GitLab](<https://devfeed.tech/sources/gitlab.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Hackathon](<https://devfeed.tech/topics/hackathon.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [gitlab-ci](<https://devfeed.tech/topics/gitlab-ci.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [GitLab](<https://devfeed.tech/topics/gitlab.md>), [3D](<https://devfeed.tech/topics/3d.md>)

Tags: [3d](<https://devfeed.tech/tags/3d.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [automated](<https://devfeed.tech/tags/automated.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [bug](<https://devfeed.tech/tags/bug.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [community](<https://devfeed.tech/tags/community.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [control](<https://devfeed.tech/tags/control.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [email](<https://devfeed.tech/tags/email.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [flow](<https://devfeed.tech/tags/flow.md>), [generation](<https://devfeed.tech/tags/generation.md>), [gitlab](<https://devfeed.tech/tags/gitlab.md>), [graph](<https://devfeed.tech/tags/graph.md>), [hackathon](<https://devfeed.tech/tags/hackathon.md>), [math](<https://devfeed.tech/tags/math.md>), [npm](<https://devfeed.tech/tags/npm.md>), [npm-package](<https://devfeed.tech/tags/npm-package.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [payment](<https://devfeed.tech/tags/payment.md>), [pharmacy](<https://devfeed.tech/tags/pharmacy.md>)

### AI overview

The Transcend Hackathon challenged developers to use GitLab Duo Agent Platform to move work from code to production, with varying levels of human oversight. The winners show agents handling investigation, fixes and routing while tests, CI checks and people provide controls. Examples include Aftermath, which traces CI exposure from a compromised npm package and requires human sign-off on investigation scope and containment; ShakeFix, which tested and deployed a pharmacy bug fix in 18 minutes and 34 seconds without human intervention; and Unstuck, which completed dependency upgrades through reviewed merge requests, pausing when behavior changes. Locus released tactile math graphs only after they passed touch-rule checks. Other projects covered benefits-payment corrections, code review preferences, changing security conditions, risk-based autonomy and lower-carbon CI. The excerpt describes selected winners and examples, not every project in the gallery.

### Source excerpt

Code generation is the easy part now. The hard part is everything that comes after it: getting software from a working change to running in production. That's the problem we put to the community in the Transcend Hackathon: "Life after code, the path to production at the speed of imagination". The hackathon, which ran during October, challenged participants to build agents and flows on GitLab Duo Agent Platform that can take over the work after the code is written. They also had to decide how much control to hand the agents, from approving every step to making them completely autonomous. More than 3,300 developers registered and 783 projects were submitted. The winning projects show how far agents and flows can go after code generation. A pharmacy app bug reported simply by shaking a phone was fixed and shipped in 18 minutes with no human in the middle. A teacher's email became a 3D-printable math graph a blind student could read by touch. A flow applied to a benefits software app helped detect payment miscalculations based on a won appeal. What these projects share: Agents do the reading, writing, and routing, while automated checks and people make the final calls. The winners The prize pool was $45,000 across nine categories, with each project eligible for one path prize and one special prize. You can find the full field in the project gallery. Path A: Start Fresh New projects built from scratch on GitLab Best Assisted Agent ($4,000): Aftermath Aftermath by Ahadi Cyizere answers the question scanners can't: When a hijacked npm package is disclosed, had it already run in last week's CI? A custom GitLab Duo flow with three subagents traces past CI jobs and the credentials each job could reach. A person signs off on the scope of the investigation, then on the containment plan, and finally closes the incident once CI has rotated only the exposed keys and deleted the affected images, and proof is attached. Best Supervised Agent ($4,000): Lookback Lookback by Ujwal Sures

## Making an OS From Scratch - Bootstrapping the dev loop

DevFeed: [Making an OS From Scratch - Bootstrapping the dev loop](<https://devfeed.tech/articles/making-an-os-from-scratch-bootstrapping-the-dev-loop-139623.md>)

Original publisher: [Read original article](<https://www.timdbg.com/posts/dbgos/>)

Author: Tim Misiak

Published: 2026-11-17T19:30:40Z

Content type: article

Language: en

Sources: [TimDbg](<https://devfeed.tech/sources/timdbg.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [bootstrapping](<https://devfeed.tech/tags/bootstrapping.md>), [build](<https://devfeed.tech/tags/build.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [dev-loop](<https://devfeed.tech/tags/dev-loop.md>), [os](<https://devfeed.tech/tags/os.md>)

### AI overview

The article's practical approach is to build a fast, automated test loop in QEMU, then move to real hardware once essential drivers work. Run the coding agent inside an isolated Linux sandbox, and use QEMU for image builds, tests, and remote viewing through noVNC or serial output. Emulation supports cross platform work; KVM virtualization is faster and can expose hardware differences, but nested virtualization or access to /dev/kvm may be required. For real hardware, choose documented devices deliberately: the author recommends e1000/e1000e wired networking as an accessible early target, while Wi-Fi is described as much more complex. A UEFI framebuffer can provide basic graphics, though it lacks vsync and resolution changes and software rendering is slow; the author identifies Intel Gen9 integrated GPUs as a relatively accessible acceleration target. USB image flashing is simple but slows iteration, so the article recommends network based image or binary loading, followed by USB storage and trial boot rollback. These are the author's experience and suggestions; the excerpt says AWS/Azure support was not explored directly.

### Source excerpt

I made an OS, and you should too I've always wanted to make my own OS, but it felt like an insurmountable project. I knew many of the pieces that would be needed, but not all of them. And to realistically make something usable or even useful in any small way seemed impossible. AI changes the equation. While it sucks most of the fun out of coding, it opens up the possibility of being the architect for a larger project without having to know every detail.

## How I Built an iPhone App That Unlocks Screen Time With Exercise

DevFeed: [How I Built an iPhone App That Unlocks Screen Time With Exercise](<https://devfeed.tech/articles/how-i-built-an-iphone-app-that-unlocks-screen-time-with-exercise-136908.md>)

Original publisher: [Read original article](<https://hackernoon.com/how-i-built-an-iphone-app-that-unlocks-screen-time-with-exercise?source=rss>)

Author: Evan

Published: 2026-11-17T07:30:02Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [iphone](<https://devfeed.tech/topics/iphone.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [activity-report](<https://devfeed.tech/tags/activity-report.md>), [api](<https://devfeed.tech/tags/api.md>), [callback](<https://devfeed.tech/tags/callback.md>), [camera](<https://devfeed.tech/tags/camera.md>), [computer-vision](<https://devfeed.tech/tags/computer-vision.md>), [counter](<https://devfeed.tech/tags/counter.md>), [exercise](<https://devfeed.tech/tags/exercise.md>), [exercise-based-app-unlock](<https://devfeed.tech/tags/exercise-based-app-unlock.md>), [ios](<https://devfeed.tech/tags/ios.md>), [iphone](<https://devfeed.tech/tags/iphone.md>), [iphone-app-blocker](<https://devfeed.tech/tags/iphone-app-blocker.md>), [iphone-fitness-tracking](<https://devfeed.tech/tags/iphone-fitness-tracking.md>), [screen-time](<https://devfeed.tech/tags/screen-time.md>), [swift](<https://devfeed.tech/tags/swift.md>), [swiftui-development](<https://devfeed.tech/tags/swiftui-development.md>), [vision](<https://devfeed.tech/tags/vision.md>)

### AI overview

Pull to Refresh counts exercise reps on-device from Vision body-pose frames, then uses Screen Time extensions to lock selected apps and grant earned access. Five exercises reduce poses to one smoothed value each; a shared threshold state machine counts a rep only after contraction and extension, with depth hints and a speed limit. Screen Time rules run across separate processes that share App Group state. Because callbacks can echo during registration or shutdown, the app routes them through a policy check backed by spent-allowance records; it also registers unlock expiry before lifting shields to avoid leaving a rule open at the 20-activity limit. iOS allows 20 monitored activities and intervals of at least 15 minutes; per-app usage is visible only to a report extension, which can render but not return the numbers. From iOS 26.5, a shield action can open the app directly; older systems rely on a local notification, which may be unavailable when notifications are disabled. Distribution requires Family Controls entitlement approval for each Screen Time extension. The author notes limits: deleting the app removes its locks, and camera-based counting can be fooled.

### Source excerpt

Counting push-ups from Vision body pose with one state machine, and what Screen Time's shields, callbacks and 20-activity limit really allow.

[Next page](<https://devfeed.tech/topics/tdd.md?cursor=WyIyMDI2LTExLTE3VDA3OjMwOjAyKzAwOjAwIiwgIjdlZGZmZDQ0LWVjMGUtNDE1Mi1iMWEyLTJiMzA2NTNkNmJiMiJd>)