# Spec Driven Development

Spec-Driven Development is a software development methodology in which explicit specifications guide implementation and verification, with some approaches using specifications to generate working code.

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

## 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 [...]

## Agentic Harness Engineering Beta: Requirement-Centered Evolution of Agent Harnesses

DevFeed: [Agentic Harness Engineering Beta: Requirement-Centered Evolution of Agent Harnesses](<https://devfeed.tech/articles/agentic-harness-engineering-beta-requirement-centered-evolution-of-agent-harnesses-142220.md>)

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

Author: Jiahang Lin, Jiahao Chen, Yiding Wang, Shichun Liu, Chengjun Pan, Shihan Dou, Honglin Guo, Yuyang Hu, Changhao Jiang, Zhenhua Han, Hang Yan, Qi Zhang, Tao Gui, Xuanjing Huang

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>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [AI Engineering](<https://devfeed.tech/topics/ai-engineering.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-harnesses](<https://devfeed.tech/tags/agent-harnesses.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [base](<https://devfeed.tech/tags/base.md>), [based](<https://devfeed.tech/tags/based.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [beta](<https://devfeed.tech/tags/beta.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [change](<https://devfeed.tech/tags/change.md>), [changes](<https://devfeed.tech/tags/changes.md>), [claude](<https://devfeed.tech/tags/claude.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [harness](<https://devfeed.tech/tags/harness.md>), [harness-engineering](<https://devfeed.tech/tags/harness-engineering.md>)

### AI overview

AHE-Beta evolves agent harnesses around verified user requirements: simulated users raise issues over multiple turns, a team implements generalizable changes, and changes are merged only after resolving a verified requirement and passing review. On held-out tasks, it raises pass@1 from 21.9% to 33.3% while using 40.8% fewer tokens than Base Harness, and the abstract reports higher pass@1 than Claude Code, Meta-Harness, and AHE. In a blind human A/B test, users preferred it in 31 of 48 valid pairs and rated it higher on all five dimensions. Without further evolution, reported pass@1 gains over Base Harness transferred to GLM-5.3 (15.8%) and DeepSeek-V4.1-Flash (5.3%).

### Source excerpt

arXiv:2611.24924v1 Announce Type: new Abstract: Real-world harness engineering is driven by explicit and implicit user requirements, which guide development and validation. However, existing harness evolution methods often overlook implicit requirements and interaction needs, while using a single evolution agent to modify the harness and benchmark scores to select changes. This process often produces narrow patches and leads to benchmark-specific local optima. We introduce Agentic Harness Engineering Beta (AHE-Beta), a requirement-centered loop that brings real-world engineering practices into harness evolution. The loop consists of three steps: (1) User-driven evaluation lets simulated users raise their requirements as issues while they work with the harness over multiple turns. (2) Team-based modification implements those requirements as generalizable changes rather than task-specific patches. (3) Requirement-driven selection merges a change only when it resolves a verified requirement and passes review. Empirically, on held-out tasks, AHE-Beta raises pass@1 from 21.9% to 33.3% while using 40.8% fewer tokens than Base Harness, and achieves higher pass@1 than Claude Code, Meta-Harness, and AHE. In a blind human A/B test, real users prefer AHE-Beta in 31 of 48 valid pairs and rate it higher on all five dimensions, matching the directional preference of the user simulator. The human A/B results show that AHE-Beta achieves its goal of aligning harness evolution with real-world user requirements. Without further evolution, the gains transfer to GLM-5.3 and DeepSeek-V4.1-Flash with pass@1 improvements of 15.8% and 5.3% over Base Harness. Together, these results show that requirement-centered harness evolution is a more general method for improving agent capabilities.

## Systematic Mapping Protocol. Generative AI-Augmented Requirements Engineering: A Systematic Mapping Study of Practices, Specifications, and Reuse in Software Development

DevFeed: [Systematic Mapping Protocol. Generative AI-Augmented Requirements Engineering: A Systematic Mapping Study of Practices, Specifications, and Reuse in Software Development](<https://devfeed.tech/articles/systematic-mapping-protocol-generative-ai-augmented-requirements-engineering-a-systematic-mapping-study-of-practices-specifications-and-reuse-in-software-development-142182.md>)

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

Author: Fernando Pinciroli

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: [Requirements](<https://devfeed.tech/topics/requirements.md>), [Generative AI](<https://devfeed.tech/topics/generative-ai.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Specifications](<https://devfeed.tech/topics/specifications.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [classification](<https://devfeed.tech/tags/classification.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data-extraction](<https://devfeed.tech/tags/data-extraction.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [requirements-engineering](<https://devfeed.tech/tags/requirements-engineering.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [threats](<https://devfeed.tech/tags/threats.md>), [transparency](<https://devfeed.tech/tags/transparency.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The document sets out a protocol for a systematic mapping study of generative AI in requirements engineering, focusing on the specifications it produces and how those work products are used downstream. It asks how they support activities such as specification-driven development, design and code generation, test derivation, verification, and reuse. The protocol specifies research questions and classification schemes, search and study selection procedures, data extraction and analysis, tool support, and threats to validity. Published in advance, it aims to establish prior commitment and make the planned study transparent and repeatable; it reports a protocol, not mapping results.

### Source excerpt

arXiv:2611.23349v1 Announce Type: new Abstract: Generative artificial intelligence (GenAI), particularly large language models (LLMs), is rapidly being adopted in requirements engineering (RE). Existing secondary studies have characterized which RE activities are supported and which prompting strategies are used, but little is known about the specifications that GenAI-augmented RE produces and how they are used in subsequent activities such as specification-driven development (SDD), design and code generation, test derivation, verification, and reuse. This document presents the protocol of a systematic mapping study (SMS) that will identify and classify research on GenAI-augmented RE, with particular attention to the work products it generates and their downstream use. The protocol defines the research questions and their classification schemes, the search strategy, the study selection procedure, the data extraction form, the analysis approach, the tool support, and the threats to validity. It is published in advance to establish a prior commitment and to support the transparency and repeatability of the study.

## Thoughts on Verification Engineering in the Agentic SDLC

DevFeed: [Thoughts on Verification Engineering in the Agentic SDLC](<https://devfeed.tech/articles/thoughts-on-verification-engineering-in-the-agentic-sdlc-142073.md>)

Original publisher: [Read original article](<https://www.dataengineeringweekly.com/p/thoughts-on-verification-engineering>)

Author: Ananth Packkildurai

Published: 2026-11-18T21:59:55Z

Content type: article

Language: en

Sources: [Data Engineering Weekly](<https://devfeed.tech/sources/data-engineering-weekly.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [reliability-engineering](<https://devfeed.tech/topics/reliability-engineering.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-sdlc](<https://devfeed.tech/tags/agentic-sdlc.md>), [agentic-software](<https://devfeed.tech/tags/agentic-software.md>), [agentic-software-development](<https://devfeed.tech/tags/agentic-software-development.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-coding-assistants](<https://devfeed.tech/tags/ai-coding-assistants.md>), [code](<https://devfeed.tech/tags/code.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [manufacturing](<https://devfeed.tech/tags/manufacturing.md>), [sdlc](<https://devfeed.tech/tags/sdlc.md>), [software](<https://devfeed.tech/tags/software.md>), [software-supply-chain](<https://devfeed.tech/tags/software-supply-chain.md>), [supply-chain](<https://devfeed.tech/tags/supply-chain.md>), [thoughts](<https://devfeed.tech/tags/thoughts.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The article argues that AI accelerates code production faster than existing review and testing loops can verify it, shifting the engineering bottleneck toward proving behavior before release. Static analysis and human diff reviews may miss cross-service runtime failures, while relying on canaries risks exposing users to too many regressions. It proposes Verification Engineering built around disposable production-equivalent sandboxes, synthetic test data shaped by domain distributions and failure patterns, automatically generated test harnesses and correctness/performance/resource assertions, and simulated end-to-end user workflows. Requirements and designs would become executable specifications, while production logs, traces, and interactions would feed anomalies back into future sandbox tests. These are presented as a proposed discipline, not as a comparison of specific products or evidence of measured results.

### Source excerpt

When AI accelerates code manufacturing, the software supply chain bottleneck shifts from writing code to building the feedback loop that proves it works.

## Atlassian AI SDLC Index: Lower Code Costs Fail to Break Development Bottlenecks

DevFeed: [Atlassian AI SDLC Index: Lower Code Costs Fail to Break Development Bottlenecks](<https://devfeed.tech/articles/atlassian-ai-sdlc-index-lower-code-costs-fail-to-break-development-bottlenecks-141356.md>)

Original publisher: [Read original article](<https://sdtimes.com/ai-sdlc/atlassian-ai-sdlc-index-lower-code-costs-fail-to-break-development-bottlenecks/>)

Author: David Rubinstein

Published: 2026-11-18T17:00:45Z

Content type: news

Language: en

Sources: [SD Times](<https://devfeed.tech/sources/sd-times.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [atlassian](<https://devfeed.tech/topics/atlassian.md>), [Generative AI](<https://devfeed.tech/topics/generative-ai.md>), [ai code review](<https://devfeed.tech/topics/ai-code-review.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [ai-sdlc](<https://devfeed.tech/tags/ai-sdlc.md>), [ai-tools](<https://devfeed.tech/tags/ai-tools.md>), [atlassian](<https://devfeed.tech/tags/atlassian.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [code](<https://devfeed.tech/tags/code.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [code-survivorship](<https://devfeed.tech/tags/code-survivorship.md>), [costs](<https://devfeed.tech/tags/costs.md>), [development](<https://devfeed.tech/tags/development.md>), [dx](<https://devfeed.tech/tags/dx.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineering-intelligence](<https://devfeed.tech/tags/engineering-intelligence.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [financial](<https://devfeed.tech/tags/financial.md>), [index](<https://devfeed.tech/tags/index.md>), [latest-news](<https://devfeed.tech/tags/latest-news.md>), [sdlc](<https://devfeed.tech/tags/sdlc.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineers](<https://devfeed.tech/tags/software-engineers.md>)

### AI overview

Atlassian's AI SDLC Index finds that cheaper AI code generation has not removed software delivery bottlenecks. Across data from more than 500 organizations, AI-generated code rose from 49% of merged code in April 2026 to 70% in October; AI spend per unit of output fell nearly 27%, while code survivorship rebounded 9 points to 68%. Human pull request reviews grew at their fastest month-over-month rate in October, and engineers still spent about 58% of their time building features, a share largely unchanged for nearly two years. The report says planning and documentation correlate most strongly with code quality, yet only about 62% of organizations rated those practices favorably. Atlassian recommends tracking code survivorship, improving specifications and documentation, and creating structured time for experimentation. The supplied excerpt says the index will be updated quarterly.

### Source excerpt

Artificial intelligence is rapidly driving down the financial cost of generating software code, yet it has not made the overall job of software engineers significantly easier. That is the central finding of the newly released Atlassian AI SDLC Index, which analyzed engineering intelligence data from more than 500 organizations via DX. The index lays bare... ... continue reading The post Atlassian AI SDLC Index: Lower Code Costs Fail to Break Development Bottlenecks appeared first on SD Times.

## Persistent Recursive Worlds Enable Autonomous Software Evolution

DevFeed: [Persistent Recursive Worlds Enable Autonomous Software Evolution](<https://devfeed.tech/articles/persistent-recursive-worlds-enable-autonomous-software-evolution-139568.md>)

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

Author: Beichen Huang, Zhenyu Liang, Bowen Zheng, Ran Cheng

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: [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [long-running](<https://devfeed.tech/topics/long-running.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [experience report](<https://devfeed.tech/topics/experience-report.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-software](<https://devfeed.tech/tags/autonomous-software.md>), [backend](<https://devfeed.tech/tags/backend.md>), [basis](<https://devfeed.tech/tags/basis.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [c](<https://devfeed.tech/tags/c.md>), [can](<https://devfeed.tech/tags/can.md>), [case](<https://devfeed.tech/tags/case.md>), [changes](<https://devfeed.tech/tags/changes.md>), [code](<https://devfeed.tech/tags/code.md>), [comes](<https://devfeed.tech/tags/comes.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [cs-ne](<https://devfeed.tech/tags/cs-ne.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [software](<https://devfeed.tech/tags/software.md>), [worlds](<https://devfeed.tech/tags/worlds.md>)

### AI overview

EvoX Genesis aims to make software development cumulative across short-lived agent sessions by having agents work from accepted repository versions, delegate within local scopes, and submit changes for verification and parent review. Accepted changes, contracts, and tests carry into later episodes. In one study, 1,019 episodes built a C compiler from scratch over 123.4 hours; repairs raised passes on a fixed 100-program Csmith set from 61 to 93, retained by a subsequent revision. A separate lineage continued from a GLM 5.2 snapshot inherited by DeepSeek V4 Flash. Other studies assessed a Rust redevelopment of selected MESA functionality against a Fortran reference across six workloads, and tracked WebGL repairs and regressions against conformance pages, reaching 2,017/2,019. The abstract presents these as evidence that inherited implementations and explicit evaluation criteria can support continued development; it does not establish that all trajectories avoid regressions.

### Source excerpt

arXiv:2608.10450v4 Announce Type: replace Abstract: Software systems accumulate dependencies and design commitments over time, while the agents that modify them operate within bounded sessions. How, then, can development remain cumulative across generations of transient agents? We introduce EvoX Genesis, which organizes development as a persistent recursive software world. Agents enter an accepted repository version, delegate work within local scopes, and submit changes for verification and parent review. Once accepted, those changes pass to later episodes together with the contracts and tests used to assess them. The project thus preserves both earlier work and a basis for evaluating what comes next. We examine this continuity through four studies of formation, continuation and redevelopment. Starting without compiler code, Genesis built a C compiler with 219,676 lines of Rust source through 1,019 agent episodes over 123.4 hours. Within this growing implementation, repairs increased passes on a fixed set of 100 Csmith programs from 61 to 93; a subsequent revision retained all 93 passes. Development also continued in a separate compiler lineage when DeepSeek V4 Flash inherited a GLM 5.2 snapshot. To examine continuity when the implementation itself changes, Genesis redeveloped selected MESA functionality in Rust, with numerical agreement assessed against the Fortran reference across six workloads. The WebGL trajectory, meanwhile, exposed both repairs and regressions as repeated checks recorded progress towards 2,017/2,019 conformance pages passed. A complementary EvoX Compiler case connects program-merging performance to executable graph and backend contracts. Together, these records trace how accepted work becomes a foundation for further development: later agents inherit both usable implementations and concrete ways to assess further revisions.

## BehaVerify: A Formal Verification Tool for Behavior Trees

DevFeed: [BehaVerify: A Formal Verification Tool for Behavior Trees](<https://devfeed.tech/articles/behaverify-a-formal-verification-tool-for-behavior-trees-139605.md>)

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

Author: Serena S. Serbinowska (Vanderbilt University), Ben Wooding (Vanderbilt University), Diego Manzanas Lopez (Vanderbilt University), Luke Nam (Vanderbilt University), Anne M. Tumlin (Vanderbilt Universit

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

Content type: article

Language: en

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

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Jule](<https://devfeed.tech/topics/jule.md>), [Isaac Sim](<https://devfeed.tech/topics/isaac-sim.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [behaviors](<https://devfeed.tech/tags/behaviors.md>), [bt](<https://devfeed.tech/tags/bt.md>), [critical](<https://devfeed.tech/tags/critical.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-ro](<https://devfeed.tech/tags/cs-ro.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [domain-specific-language](<https://devfeed.tech/tags/domain-specific-language.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [formal](<https://devfeed.tech/tags/formal.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [linear](<https://devfeed.tech/tags/linear.md>), [logic](<https://devfeed.tech/tags/logic.md>), [monitors](<https://devfeed.tech/tags/monitors.md>), [tool](<https://devfeed.tech/tags/tool.md>), [trees](<https://devfeed.tech/tags/trees.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

BehaVerify provides a DSL for modeling behavior trees and Neuro-Symbolic behavior trees, with Linear Temporal Logic and Computation Tree Logic specifications. It checks whether specifications hold by encoding the trees into nuXmv using a method called fastforwarding. The toolbox can also generate Python and Haskell implementations; its Python support integrates with PyTrees and ROS and has been deployed on autonomous robotic systems, including for runtime monitor verification. The manuscript focuses on the toolbox's use, features, and implementation. The supplied text does not give benchmark results or detail the verification limits.

### Source excerpt

arXiv:2611.22403v1 Announce Type: new Abstract: This paper presents BehaVerify, a verification toolbox for behavior trees (BTs) and Neuro-Symbolic BTs. BTs are a graphical language for planning and sequencing behaviors - similar to extended state machines - and are increasingly used in safety-critical domains. BehaVerify enables users to specify a BT using a Domain Specific Language (DSL) with formal syntax and semantics. This language further includes Linear Temporal Logic and Computation Tree Logic specifications. BehaVerify uses an efficient encoding into nuXmv, called fastforwarding, to quickly verify if a specification holds over the BT. Additionally, BehaVerify can generate implementations of the BT in Python and Haskell. Through Python, BehaVerify has been integrated with PyTrees and Robot Operating System (ROS) and has been deployed to several autonomous robotic systems, including for verifying runtime monitors. While prior works have developed the underlying theory, this manuscript focuses on the toolbox usage, functionality and implementation. BehaVerify is open source: https://github.com/verivital/behaverify

## Is This Code Mine? Student Ownership When AI Agents Write the Spec and the Code

DevFeed: [Is This Code Mine? Student Ownership When AI Agents Write the Spec and the Code](<https://devfeed.tech/articles/is-this-code-mine-student-ownership-when-ai-agents-write-the-spec-and-the-code-138018.md>)

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

Author: Gustavo Pinto, Enne Rebeca Silva de Freitas, Danilo Monteiro Ribeiro

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

Content type: opinion

Language: en

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

Topics: [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Vibe coding](<https://devfeed.tech/topics/vibe-coding.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [spec](<https://devfeed.tech/tags/spec.md>), [spec-driven-development](<https://devfeed.tech/tags/spec-driven-development.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [student](<https://devfeed.tech/tags/student.md>), [students](<https://devfeed.tech/tags/students.md>), [teaching](<https://devfeed.tech/tags/teaching.md>)

### AI overview

In an assignment where 18 student pairs built applications with AI agents using Spec-Driven Development, repository histories, recorded prompts, and a survey of 33 students showed that agents wrote 69% of the specifications intended to keep students in control. Students credited themselves with half the ideas but only a fifth of the code; most could not explain or modify that code without the agent, and self-reports did not align with commit records. Three teams met a 100,000-line target using generated code the application did not use, and one team backdated specifications in its repository history. The authors recommend assessing what students specify, review, and can explain, and enforcing process requirements with tools.

### Source excerpt

arXiv:2611.21501v1 Announce Type: new Abstract: Software engineering courses are starting to ask students to build entire systems with AI coding agents, but little is known about what students actually do with them and whether they still own what they deliver. If the agent writes both the code and the decisions behind it, the artifacts we grade no longer show what students learned. We studied an assignment in which 18 pairs of students built applications with agents under Spec-Driven Development, combining the mined history of their repositories, the prompts they recorded, and a survey of 33 students. The agents wrote 69\% of the specifications meant to keep students in control, sometimes from a prompt of a few words. Students locate their ownership in the ideas, crediting themselves with half of them but a fifth of the code, yet most could not explain that code to a colleague or modify it without the agent, and what they report having written is unrelated to what their own commits declare. The three teams that met the 100,000-line target did so with generated code the application never uses, in one case proposed by the agent itself, and one team rewrote its history to backdate its specifications. Teaching with agents should therefore assess what students specify, review, and can explain, rather than what they ship, and enforce the engineering process with tools rather than trusting it to students or agents.

## Spec-Driven Development as Prescribed and as Practiced

DevFeed: [Spec-Driven Development as Prescribed and as Practiced](<https://devfeed.tech/articles/spec-driven-development-as-prescribed-and-as-practiced-137933.md>)

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

Author: Shyam Agarwal, Anmol Singhal, Andrew Macvean, Bogdan Vasilescu, Travis Breaux

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

Content type: article

Language: en

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

Topics: [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [AI tools for developers](<https://devfeed.tech/topics/ai-tools-for-developers.md>)

Tags: [agent-behavior](<https://devfeed.tech/tags/agent-behavior.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [costs](<https://devfeed.tech/tags/costs.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [development](<https://devfeed.tech/tags/development.md>), [planning](<https://devfeed.tech/tags/planning.md>), [process](<https://devfeed.tech/tags/process.md>), [review](<https://devfeed.tech/tags/review.md>), [spec-driven-development](<https://devfeed.tech/tags/spec-driven-development.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [study](<https://devfeed.tech/tags/study.md>)

### AI overview

The study finds that practitioners value specifications for capturing intent when using AI coding agents, but often include implementation details and use spec-driven development selectively, mainly for new features. Interviews with 21 practitioners, Reddit discussions, and an analysis of 266 repositories found reports of more reliable agent behavior alongside greater planning and review costs. Implementation detail may help agents but can make specs decay; tool-specific record structures affect what people and agents see. Participants described spec-code checks mostly at completion rather than over time. The authors suggest individual gains may come from clarifying intent before delegation, while team benefits may require SDD as a shared process.

### Source excerpt

arXiv:2608.25202v5 Announce Type: replace Abstract: AI coding agents implement software from naturallanguage instructions, but the intent behind that work is lost when stated only in chat sessions. Spec-driven development (SDD) addresses this by having developers and agents write specifications that guide implementation, yet evidence on its use comes largely from tool vendors. We study SDD in practice through a thematic analysis of Reddit discussions, interviews with 21 practitioners, including eight tool makers, and 266 active and popular repositories in SpecMine, a corpus of 470,795 spec files from 73,030 public GitHub repositories that we release. Practitioners agreed that specs should capture intent, but many also included implementation details, used SDD selectively and mainly for new features, and reported more reliable agent behavior alongside greater planning and review costs. Our findings show that implementation detail may help agents while making specs prone to decay, that tool-specific record structures shape what people and agents see, and that participants described spec-code checks mainly when changes are completed rather than over time. We also find that individual benefits may come from clarifying intent before delegation, while team benefits may depend on SDD becoming a shared process. We derive implications for tool builders, practitioners, and researchers.

## How Specification Explicitness Shapes Failure in LLM-Generated Code

DevFeed: [How Specification Explicitness Shapes Failure in LLM-Generated Code](<https://devfeed.tech/articles/how-specification-explicitness-shapes-failure-in-llm-generated-code-137546.md>)

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

Author: Elmira Onagh, Maleknaz Nayebi

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

Content type: news

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: [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Specifications](<https://devfeed.tech/topics/specifications.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [behavior](<https://devfeed.tech/tags/behavior.md>), [code](<https://devfeed.tech/tags/code.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [developers](<https://devfeed.tech/tags/developers.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [failure](<https://devfeed.tech/tags/failure.md>), [failures](<https://devfeed.tech/tags/failures.md>), [invariant](<https://devfeed.tech/tags/invariant.md>), [invariants](<https://devfeed.tech/tags/invariants.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [python](<https://devfeed.tech/tags/python.md>), [regressions](<https://devfeed.tech/tags/regressions.md>), [requirements](<https://devfeed.tech/tags/requirements.md>), [specification](<https://devfeed.tech/tags/specification.md>), [specifications](<https://devfeed.tech/tags/specifications.md>)

### AI overview

In a controlled study with 72 participants implementing and revising Python tasks with an LLM, lightweight specification structure reduced hidden-test failures by 8.7%, while explicit behavioral obligations--such as constraints, invariants, edge cases, tie-breaking, and exception handling--reduced failures by 47.2% and distinct failure modes by 20.5%. Invariant violations fell 66.1%, and unsupported assumptions fell 59.5%. After requirements changed, explicit specifications caused regressions in more submissions, but each affected submission lost less previously correct behavior. Participants without explicit obligations overestimated correctness by about 23 percentage points; with them, they produced better code and judged it more cautiously.

### Source excerpt

arXiv:2611.20195v1 Announce Type: cross Abstract: When LLMs turn requirements into code, every underspecified constraint becomes behavior that the model must decide during generation. We test when specifications move beyond structure and begin to control generated behavior. In a controlled experiment, 72 participants implemented and revised Python tasks with an LLM under three levels of specification explicitness. The results show a clear break between lightweight structure and explicit behavioral obligations. Lightweight structure reduced hidden-test failures by only 8.7%. Requiring participants to specify constraints, invariants, negative requirements, edge cases, tie-breaking rules, and exception handling cut failures by 47.2% and reduced the number of distinct failure modes by 20.5%. The largest drops were in failure modes tied to implicit obligations. Invariant violations fell by 66.1%, and unsupported assumptions fell by 59.5%. After a requirement change, specifications with explicit behavioral obligations produced regressions in more submissions, but each affected submission lost less previously correct behavior. Explicit specifications also changed how developers judged generated code. Without explicit obligations, participants overestimated generated-code correctness by about 23 percentage points. With explicit obligations, they produced better code but judged it more cautiously. Thus, the lesson is sharper than "better specifications help." Lightweight structure barely helped, while explicit behavioral obligations nearly halved failures, made regressions shallower, and improved calibration.

## Modernizing mainframe Assembler to Java using Amazon Bedrock and AWS Transform

DevFeed: [Modernizing mainframe Assembler to Java using Amazon Bedrock and AWS Transform](<https://devfeed.tech/articles/modernizing-mainframe-assembler-to-java-using-amazon-bedrock-and-aws-transform-136123.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/machine-learning/modernizing-mainframe-assembler-to-java-using-amazon-bedrock-and-aws-transform/>)

Author: Abhishek Ashish

Published: 2026-11-16T17:29:29Z

Content type: tutorial

Language: en

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

Topics: [AWS Transform](<https://devfeed.tech/topics/aws-transform.md>), [Amazon Bedrock](<https://devfeed.tech/topics/amazon-bedrock.md>), [Mainframe](<https://devfeed.tech/topics/mainframe.md>), [Java](<https://devfeed.tech/topics/java.md>), [Spring Framework](<https://devfeed.tech/topics/spring-framework.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [amazon-bedrock](<https://devfeed.tech/tags/amazon-bedrock.md>), [assembler](<https://devfeed.tech/tags/assembler.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-transform](<https://devfeed.tech/tags/aws-transform.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [cobol](<https://devfeed.tech/tags/cobol.md>), [intermediate-200](<https://devfeed.tech/tags/intermediate-200.md>), [java](<https://devfeed.tech/tags/java.md>), [java-spring](<https://devfeed.tech/tags/java-spring.md>), [java-spring-boot](<https://devfeed.tech/tags/java-spring-boot.md>), [kiro](<https://devfeed.tech/tags/kiro.md>), [kiro-ide](<https://devfeed.tech/tags/kiro-ide.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [mainframe](<https://devfeed.tech/tags/mainframe.md>), [methodology](<https://devfeed.tech/tags/methodology.md>), [modernizing](<https://devfeed.tech/tags/modernizing.md>), [rules](<https://devfeed.tech/tags/rules.md>), [spring-boot](<https://devfeed.tech/tags/spring-boot.md>)

### AI overview

The article outlines a five-phase path for modernizing Assembler applications: use Amazon Bedrock with Kiro IDE or the Bedrock console to extract business rules and draft functional specifications; have subject matter experts validate them; generate intermediate COBOL guided by those specifications; test its functional equivalence to the Assembler; then use AWS Transform to convert validated COBOL into Java Spring Boot applications. It presents the COBOL stage and checkpoints as ways to reduce conversion risk and catch errors earlier than direct conversion. Bedrock supports the first four phases, while AWS Transform handles COBOL-to-Java conversion. Prerequisites include appropriate AWS access, source documentation, domain expertise, SMEs, and test data. The article recommends sanitized data, consistent model settings, and SME review because AI outputs are drafts and may miss domain logic or edge cases. It does not provide measured time savings or equivalence results.

### Source excerpt

Legacy mainframe Assembler applications are costly to maintain and hard to staff. This post presents a multi-stage, AI-powered methodology using Amazon Bedrock, Kiro IDE, and AWS Transform to extract business rules, convert Assembler through an intermediate COBOL stage, and deploy modernized Java Spring Boot applications on AWS.

## 🍔🧠 AWS built a fake cloud to test real code

DevFeed: [🍔🧠 AWS built a fake cloud to test real code](<https://devfeed.tech/articles/aws-built-a-fake-cloud-to-test-real-code-136057.md>)

Original publisher: [Read original article](<https://hungrymindsdev.substack.com/p/aws-built-a-fake-cloud-to-test-real>)

Author: Alexandre Zajac

Published: 2026-11-16T16:31:11Z

Content type: article

Language: en

Sources: [Hungry Minds](<https://devfeed.tech/sources/hungry-minds.md>)

Topics: [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Mocking](<https://devfeed.tech/topics/mocking.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>)

Tags: [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-teammates](<https://devfeed.tech/tags/ai-teammates.md>), [ai-trends](<https://devfeed.tech/tags/ai-trends.md>), [alex](<https://devfeed.tech/tags/alex.md>), [also](<https://devfeed.tech/tags/also.md>), [amazon](<https://devfeed.tech/tags/amazon.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [aws](<https://devfeed.tech/tags/aws.md>), [code](<https://devfeed.tech/tags/code.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [http](<https://devfeed.tech/tags/http.md>), [meta](<https://devfeed.tech/tags/meta.md>), [redis](<https://devfeed.tech/tags/redis.md>), [spec](<https://devfeed.tech/tags/spec.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

AWS Emulator uses public service API models and customer scenarios to approximate more than 200 AWS services locally. Agents build fidelity tests, check them against real AWS, then develop the emulator to pass those same tests; an SQS scenario, for example, checks whether a received message stays hidden until its visibility timeout expires. AWS reports the emulator covers more than 400 API models and runs offline, with automated merge checks that include security review agents. The approach makes local testing possible at broad service scale, but does not establish that the emulator captures every production failure. The Alf lock-service experience found different problems in simulation and on real servers, underscoring the need to validate models against reality and continue real-system testing.

### Source excerpt

PLUS: Shopify drops Redis 🫨, Meta tunes GPU kernels 🧬, and GraphQL gets an HTTP spec ⚡

## Software engineering after code becomes cheap with Satya Nadella

DevFeed: [Software engineering after code becomes cheap with Satya Nadella](<https://devfeed.tech/articles/software-engineering-after-code-becomes-cheap-with-satya-nadella-136143.md>)

Original publisher: [Read original article](<https://newsletter.pragmaticengineer.com/p/software-engineering-after-code-becomes>)

Author: Gergely Orosz

Published: 2026-11-16T13:33:48Z

Content type: article

Language: en

Sources: [The Pragmatic Engineer](<https://devfeed.tech/sources/the-pragmatic-engineer.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [Platform Engineering](<https://devfeed.tech/topics/platform-engineering.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [AI Engineering](<https://devfeed.tech/topics/ai-engineering.md>), [future of software](<https://devfeed.tech/topics/future-of-software.md>)

Tags: [agentic-systems](<https://devfeed.tech/tags/agentic-systems.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-accelerated-development](<https://devfeed.tech/tags/ai-accelerated-development.md>), [ai-generated-code](<https://devfeed.tech/tags/ai-generated-code.md>), [ai-infrastructure](<https://devfeed.tech/tags/ai-infrastructure.md>), [ai-models](<https://devfeed.tech/tags/ai-models.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [azure](<https://devfeed.tech/tags/azure.md>), [careers](<https://devfeed.tech/tags/careers.md>), [ceo](<https://devfeed.tech/tags/ceo.md>), [code](<https://devfeed.tech/tags/code.md>), [code-verification](<https://devfeed.tech/tags/code-verification.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [satya-nadella](<https://devfeed.tech/tags/satya-nadella.md>), [software](<https://devfeed.tech/tags/software.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Nadella argues that as AI makes code generation cheap, verifying generated code becomes a central, unresolved engineering challenge. He describes teams building "software factories" that use agents to improve existing operations, and says specifications and verification matter more as tools and workflows change quickly. Microsoft's experience with GitHub Copilot falling behind Claude Code illustrates how a shift from IDEs to command-line agents can reshape a product's form factor in months. For AI infrastructure, he recommends keeping the harness, memory, and model replaceable, using private evaluations, and treating agents as insider risks that need separate safeguards. He expects hybrid intelligence to route work between local models and more capable, costly cloud models. The conversation also covers Microsoft's restructuring, slower junior hiring during teams' transition to new workflows, and a PRAISE program pairing experienced engineers with early-career developers. His practical advice is to use AI hands-on and learn through teams doing the work.

### Source excerpt

Microsoft CEO Satya Nadella on AI's impact on software engineering, code verification, and engineers' careers.

## How We Reached 99% Line Coverage in a React Native App

DevFeed: [How We Reached 99% Line Coverage in a React Native App](<https://devfeed.tech/articles/how-we-reached-99-line-coverage-in-a-react-native-app-134517.md>)

Original publisher: [Read original article](<https://hackernoon.com/how-we-reached-99percent-line-coverage-in-a-react-native-app?source=rss>)

Author: John Adib

Published: 2026-11-15T13:37:46Z

Content type: article

Language: en

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

Topics: [React Native](<https://devfeed.tech/topics/react-native.md>), [Expo](<https://devfeed.tech/topics/expo.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [mobile devops](<https://devfeed.tech/topics/mobile-devops.md>), [Instrumentation](<https://devfeed.tech/topics/instrumentation.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>)

Tags: [automated-regression-testing](<https://devfeed.tech/tags/automated-regression-testing.md>), [ci](<https://devfeed.tech/tags/ci.md>), [continuous-integration](<https://devfeed.tech/tags/continuous-integration.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [jest](<https://devfeed.tech/tags/jest.md>), [maestro](<https://devfeed.tech/tags/maestro.md>), [maestro-testing](<https://devfeed.tech/tags/maestro-testing.md>), [mobile-app-testing](<https://devfeed.tech/tags/mobile-app-testing.md>), [react-native](<https://devfeed.tech/tags/react-native.md>), [react-native-testing](<https://devfeed.tech/tags/react-native-testing.md>), [react-native-unit-tests](<https://devfeed.tech/tags/react-native-unit-tests.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The team reached 99.26% line coverage in October by making tests part of completing changes, expanding Jest unit tests, and bringing Maestro device flows into CI. The figure covered 22,903 of 23,072 eligible lines across four Jest shards; branch coverage was 95.55%, and CI thresholds were pinned to that measured baseline. The team excluded test helpers, Storybook, development-only code and other files from the production-code scope. Inventory counts grew from 113 unit-test files and 14 Maestro YAML files in April to 2,257 and 404 in October, but file counts did not establish behavioral coverage. Although repository leaf flows reached all 99 non-exempt product routes, CI-run leaves reached only 28. The article cautions that coverage cannot show whether assertions catch defects or what happens on iOS and Android; regression tests that fail against the old defect, plus device runs, screenshots and recordings, supplied other review evidence.

### Source excerpt

How one engineering team scaled React Native testing with Jest, Maestro, and CI, reaching 99.26% line coverage while improving verification.

## Software engineering when code is cheap

DevFeed: [Software engineering when code is cheap](<https://devfeed.tech/articles/software-engineering-when-code-is-cheap-134477.md>)

Original publisher: [Read original article](<https://read.theaimerge.com/p/software-engineering-when-code-is-cheap>)

Author: Alex Razvant

Published: 2026-11-15T11:31:10Z

Content type: opinion

Language: en

Sources: [Neural Bits](<https://devfeed.tech/sources/neural-bits.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [coding assistant](<https://devfeed.tech/topics/coding-assistant.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [reliable codebases](<https://devfeed.tech/topics/reliable-codebases.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [agentic-software-factory](<https://devfeed.tech/tags/agentic-software-factory.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-tools](<https://devfeed.tech/tags/ai-coding-tools.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [clicks](<https://devfeed.tech/tags/clicks.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The author's central finding is that AI makes it easy to start more code changes than engineers can understand, review, and safely ship. They recommend using agents first to gather project context, investigate the actual problem, and challenge a proposed plan; then choose a justified change, define checks that measure the requirement, and plan a rollback. Code generation is cheap, but review, integration, migration, and production responsibility still take human time. Automated reviews can help with low and medium impact work, while someone who knows a production service should judge readiness. The author also urges teams to protect senior reviewers' capacity and give junior engineers real problems, mentorship, and time to learn. They value simple task definitions and relevant context over elaborate agent setups, and note that long agent sessions can lose important details as context changes or gets summarized.

### Source excerpt

I can start more changes with AI than I can understand. Here's how I deal with that, and why it's a team problem too.

## AWS Emulator proves agents need a verification loop. Realism is the hard part.

DevFeed: [AWS Emulator proves agents need a verification loop. Realism is the hard part.](<https://devfeed.tech/articles/aws-emulator-proves-agents-need-a-verification-loop-realism-is-the-hard-part-134080.md>)

Original publisher: [Read original article](<https://thenewstack.io/aws-emulator-verification-loops/>)

Author: Arjun Iyer

Published: 2026-11-14T17:30:00Z

Content type: opinion

Language: en

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

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-engineering](<https://devfeed.tech/tags/ai-engineering.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-emulator](<https://devfeed.tech/tags/aws-emulator.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-apis](<https://devfeed.tech/tags/cloud-apis.md>), [cloud-services](<https://devfeed.tech/tags/cloud-services.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-bugs](<https://devfeed.tech/tags/concurrency-bugs.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [consumer](<https://devfeed.tech/tags/consumer.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cost](<https://devfeed.tech/tags/cost.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [data](<https://devfeed.tech/tags/data.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [post-contributed](<https://devfeed.tech/tags/post-contributed.md>), [signadot](<https://devfeed.tech/tags/signadot.md>), [software-testing](<https://devfeed.tech/tags/software-testing.md>), [sponsor-signadot](<https://devfeed.tech/tags/sponsor-signadot.md>), [sponsored-post-contributed](<https://devfeed.tech/tags/sponsored-post-contributed.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

AWS Emulator gives coding agents a fast local target for testing more than 200 AWS services; its behaviors are checked against real AWS, though the article notes gaps such as throttling, outages, and regional availability. The Alf replication-engine example illustrates how adding a spec and test environment cut an agent rebuild from four nights of supervision to about two hours. The article argues that mocks can reinforce an agent's own assumptions, emulators help with managed services that have published contracts, and only the running system exposes many failures in services a team owns. It recommends combining emulator checks with fast, isolated production-like environments that deploy only changed components, run trusted integration and end-to-end tests, and provide evidence for merge gates.

### Source excerpt

This week, Amazon Web Services released AWS Emulator, a local copy of AWS that coding agents can test against. It The post AWS Emulator proves agents need a verification loop. Realism is the hard part. appeared first on The New Stack.

## My First Time on NPR: Are We Building Software We Can't Control?

DevFeed: [My First Time on NPR: Are We Building Software We Can't Control?](<https://devfeed.tech/articles/my-first-time-on-npr-are-we-building-software-we-can-t-control-133960.md>)

Original publisher: [Read original article](<https://automateyournetwork.com/ai/wypr-thoughts-on-tech-and-things/>)

Author: John Capobianco

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

Content type: article

Language: en

Sources: [Automate Your Network](<https://devfeed.tech/sources/automate-your-network.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [article](<https://devfeed.tech/tags/article.md>), [building](<https://devfeed.tech/tags/building.md>), [building-software](<https://devfeed.tech/tags/building-software.md>), [can](<https://devfeed.tech/tags/can.md>), [community](<https://devfeed.tech/tags/community.md>), [control](<https://devfeed.tech/tags/control.md>), [development](<https://devfeed.tech/tags/development.md>), [first](<https://devfeed.tech/tags/first.md>), [itential](<https://devfeed.tech/tags/itential.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [my](<https://devfeed.tech/tags/my.md>), [netclaw](<https://devfeed.tech/tags/netclaw.md>), [network-automation](<https://devfeed.tech/tags/network-automation.md>), [npr](<https://devfeed.tech/tags/npr.md>), [public](<https://devfeed.tech/tags/public.md>), [public-radio](<https://devfeed.tech/tags/public-radio.md>), [radio](<https://devfeed.tech/tags/radio.md>), [software](<https://devfeed.tech/tags/software.md>), [specification](<https://devfeed.tech/tags/specification.md>), [specification-driven-development](<https://devfeed.tech/tags/specification-driven-development.md>), [tech](<https://devfeed.tech/tags/tech.md>), [things](<https://devfeed.tech/tags/things.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The interview's central takeaway is to use AI agents deliberately: begin with read access and triage, expand trust as earned, and keep humans involved in risky actions. The guest describes agents operating across tools and APIs, including a reported attempt to replicate NetClaw that they chose not to pursue further. They recommend specification-driven development, security, privacy, HR and finance input through an "AI council," and moving reliable agent work into deterministic workflows. The discussion also covers token costs and model choices, and cites the guest's on-air projection that agents could handle roughly 70% of network work by 2030, compared with about 1% today. The article summarizes a 49-minute interview and its examples; it does not establish the projection independently.

### Source excerpt

My national public radio debut on WYPR's Thoughts on Tech & Things with Jason Michael Perry: AI coding, specification-driven development, tokenomics, agents that escape their sandboxes, and a NetClaw check-in from my watch.

## Are We Building Software We Can't Control?

DevFeed: [Are We Building Software We Can't Control?](<https://devfeed.tech/articles/are-we-building-software-we-can-t-control-133961.md>)

Original publisher: [Read original article](<https://www.wypr.org/podcast/thoughts-on-tech-things/2026-11-13/are-we-building-software-we-cant-control>)

Author: Jason Michael Perry

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

Content type: article

Language: en

Sources: [Automate Your Network](<https://devfeed.tech/sources/automate-your-network.md>)

Topics: [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-security](<https://devfeed.tech/tags/agent-security.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [appearance](<https://devfeed.tech/tags/appearance.md>), [building](<https://devfeed.tech/tags/building.md>), [can](<https://devfeed.tech/tags/can.md>), [coding](<https://devfeed.tech/tags/coding.md>), [control](<https://devfeed.tech/tags/control.md>), [development](<https://devfeed.tech/tags/development.md>), [john](<https://devfeed.tech/tags/john.md>), [netclaw](<https://devfeed.tech/tags/netclaw.md>), [podcast](<https://devfeed.tech/tags/podcast.md>), [security](<https://devfeed.tech/tags/security.md>), [software](<https://devfeed.tech/tags/software.md>), [specification](<https://devfeed.tech/tags/specification.md>), [specification-driven-development](<https://devfeed.tech/tags/specification-driven-development.md>), [tech](<https://devfeed.tech/tags/tech.md>), [things](<https://devfeed.tech/tags/things.md>), [thoughts](<https://devfeed.tech/tags/thoughts.md>), [tokenomics](<https://devfeed.tech/tags/tokenomics.md>)

### AI overview

The episode examines how AI coding tools are changing software work and raising control and security concerns. Jason Michael Perry and John Capobianco discuss writing less code, specification-driven development, tokenomics, and engineers trusting code they have not reviewed. They also consider reports of agents circumventing restrictions, the risks of granting AI access to real infrastructure, and the challenge of controlling autonomous systems. The excerpt notes discussion of combining AI with traditional automation and whether humans may cease to be the best software writers; it does not provide detailed conclusions or specific security practices.

### Source excerpt

WYPR 88.1 FM - Podcast - John's national public radio debut on Thoughts on Tech & Things with Jason Michael Perry: AI coding, specification-driven development, tokenomics, agent security, and NetClaw on an Apple Watch.

## DafnyCert: Certifying Specification Strength in Dafny

DevFeed: [DafnyCert: Certifying Specification Strength in Dafny](<https://devfeed.tech/articles/dafnycert-certifying-specification-strength-in-dafny-131718.md>)

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

Author: \\'Alvaro Silva, Isabel Amaral, Ruben Martins, Alexandra Mendes

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

Content type: article

Language: en

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

Topics: [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [reproducibility](<https://devfeed.tech/topics/reproducibility.md>), [certificates](<https://devfeed.tech/topics/certificates.md>)

Tags: [certificate](<https://devfeed.tech/tags/certificate.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [harness](<https://devfeed.tech/tags/harness.md>), [hypothesis](<https://devfeed.tech/tags/hypothesis.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [specification](<https://devfeed.tech/tags/specification.md>), [verify](<https://devfeed.tech/tags/verify.md>)

### AI overview

DafnyCert provides independently checkable evidence of whether a Dafny specification allows only one output per input. For strength, it builds a harness around the method; verifying the harness certifies that uniqueness property. For weakness, it uses MutDafny to find an alternative implementation that verifies against the specification, then Hypothesis to find an input where its output differs from the original; the mutant and witness form a recheckable certificate. On 3,910 verified methods from Dafny-Synthesis and VeriEquivBench, the tool automatically certified 3,570 (91.3%), with certificates also provided for the remaining 340. Its strength/weakness labels differed from the benchmarks' original labels for 16.3% of methods.

### Source excerpt

arXiv:2611.15548v1 Announce Type: new Abstract: Formally verifying a method with Dafny guarantees correctness relative to its specification. However, a specification may be too permissive, allowing multiple outputs for the same input, even when the implementation produces only one. In this paper, we propose checkable certificates that provide independently verifiable evidence of whether a specification is weak or strong. A certificate of weakness contains an alternative implementation that verifies against the original specification, together with a witness input on which the original and alternative implementations produce different results. A certificate of strength is produced by constructing a harness around the original method such that successfully verifying the harness guarantees that the specification allows at most one possible output for any given input. We present DafnyCert, a tool that automatically produces these certificates. Strength is established by constructing and verifying the harness. Weakness is demonstrated by using the MutDafny mutation tool to find mutants that verify against the original specification, and by using the Hypothesis property-based testing framework to generate inputs that produce different outputs for the original program and the mutant. The resulting mutant and witness form a recheckable certificate of weakness. On a dataset of 3,910 verified Dafny methods from Dafny-Synthesis and VeriEquivBench, DafnyCert automatically certifies 3,570 methods (91.3%). We also provide certificates for the remaining 340 methods. To our knowledge, this is the first dataset in which every specification is backed by a checkable certificate of strength or weakness. These labels disagree with the benchmarks' original labels for 16.3% of the methods. These findings highlight the importance of supporting specification strength labels with independently checkable evidence.

## Spec-Driven PBT: Deriving Semantic Invariants from Code Specifications for Agentic Property-based Testing

DevFeed: [Spec-Driven PBT: Deriving Semantic Invariants from Code Specifications for Agentic Property-based Testing](<https://devfeed.tech/articles/spec-driven-pbt-deriving-semantic-invariants-from-code-specifications-for-agentic-property-based-testing-131726.md>)

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

Author: Aditya Shukla, Kartik Gupta, Ali Alavi, Pashootan Vaezipoor

Published: 2026-11-13T05: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: [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [applications](<https://devfeed.tech/tags/applications.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [invariants](<https://devfeed.tech/tags/invariants.md>), [property](<https://devfeed.tech/tags/property.md>), [property-based-testing](<https://devfeed.tech/tags/property-based-testing.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [spec](<https://devfeed.tech/tags/spec.md>), [spec-driven](<https://devfeed.tech/tags/spec-driven.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Spec-Driven PBT derives invariants from a product specification before inspecting the implementation, then translates them into property tests. In an evaluation across 25 ViBench applications, it found bugs missed by implementation-derived Code-driven PBT while writing 2.4 times fewer property tests. The approaches found roughly equivalent numbers of bugs, but nearly 60% of 169 total bugs were found by only one approach. The abstract reports that Spec-Driven PBT's unique bugs tended to violate documented workflows, while Code-driven PBT's tended to involve implementation robustness, suggesting complementary bug-finding coverage.

### Source excerpt

arXiv:2611.15920v1 Announce Type: new Abstract: Software is increasingly written by AI agents that produce an implementation from a natural language specification, a practice known as agentic coding. Code is now produced faster than it can be reviewed, and has been shown to exhibit its own characteristic failure patterns. Property-based testing (PBT), a long-standing technique in which invariant properties of a program are checked against many generated inputs, has recently been revisited with LLM agents authoring the properties, thereby removing the high-effort derivation of invariants that has long hindered its adoption. Existing methods, however, derive these properties from the implementation alone (Code-driven PBT). At the same time, a thorough specification such as a product requirements document has become routine within agentic coding, yet its role in testing the resulting code remains underexplored. We study the value of the specification as a source of properties for testing agent-written code. Our key insight is that the specification, unlike the implementation, records what the code was meant to do, and invariants derived from it are not biased by particular implementation choices. We propose Spec-Driven PBT, an agent that first expresses invariants in natural language from the specification and only then inspects the implementation to translate them into concrete tests. Across 25 applications from ViBench, Spec-Driven PBT finds a novel set of bugs that Code-driven PBT misses, while writing 2.4x fewer property tests. Though the two approaches surface a roughly equivalent number of bugs, there is little overlap: nearly 60% of the 169 total bugs are found by only one. Qualitatively, we find that the bugs unique to Spec-Driven PBT tend to violate documented product workflows whereas those to Code-driven PBT instead concentrate on implementation robustness, offering complementary value for bug discovery in agent-written code.

## AgentTorrent: A Dataset of Context and Harness Engineering Artifacts on GitHub

DevFeed: [AgentTorrent: A Dataset of Context and Harness Engineering Artifacts on GitHub](<https://devfeed.tech/articles/agenttorrent-a-dataset-of-context-and-harness-engineering-artifacts-on-github-131712.md>)

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

Author: Sebastian Baltes, Seyedmoein Mohsenimofidi, Levi B\\"ohme, Vahram Nersesyan, Muhammad Auwal Abubakar, Jai Lal Lulla, Matthias Galster, Christoph Treude

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

Content type: article

Language: en

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

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [github](<https://devfeed.tech/tags/github.md>), [harness-engineering](<https://devfeed.tech/tags/harness-engineering.md>), [planning](<https://devfeed.tech/tags/planning.md>)

### AI overview

AgentTorrent links context and harness configuration files, their imports, planning documents, and AI-credited commits across 10,944 GitHub projects, enabling study of how these artifacts relate within repositories. It includes 62,374 configuration artifacts, 27,593 planning documents, and more than 1.2 million credited commits; all three artifact types occur together in 388 repositories. Collection heuristics are based on tool documentation or repository evidence, with detection accuracy evaluated for each collection. Open-weight models classify engineered software projects, and the open-source pipeline supports updates by checking vendor documentation and reporting unknown artifacts and tools. The dataset and pipeline are archived on Zenodo.

### Source excerpt

arXiv:2611.15436v1 Announce Type: new Abstract: Over the past months, developers have moved from formulating detailed prompts to engineering the context that agentic coding tools read and to configuring the underlying harnesses. For example, developers commit context files, skills, hooks, and MCP configurations to their repositories, and these files control which instructions a harness reads and which actions it can take. Developers may also commit the specs, plans, and task files that agentic coding tools and spec-driven development frameworks write for agents to implement. The AgentTorrent dataset records these files for six proprietary and open-source agentic coding tools in 10,944 engineered software projects on GitHub. It contains 62,374 configuration artifacts, the files that these artifacts import, 27,593 agentic planning documents, and more than 1.2 million commits that credit an AI tool. All heuristics used for data collection are grounded in tool documentation or derived from GitHub repositories, and we evaluate their detection accuracy with each collection. We use open-weight models to classify whether GitHub repositories host engineered software projects. Unlike most datasets, AgentTorrent links configuration artifacts, imported files, agentic planning documents, and commits that credit an AI tool within the same repositories. Configuration artifacts, planning documents, and credited commits occur together in 388 repositories. For example, our dataset allows researchers to study whether a tool is credited in commits that add instructions for that same tool and how instruction files import and contradict each other. Our data collection pipeline supports regular updates and automatically checks vendor documentation and reports unknown artifacts and agentic coding tools. The dataset and the pipeline are open-source and are archived on Zenodo.

## Pre-QED: Environment Specifications for Agentic Verification

DevFeed: [Pre-QED: Environment Specifications for Agentic Verification](<https://devfeed.tech/articles/pre-qed-environment-specifications-for-agentic-verification-131709.md>)

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

Author: Tristan Lim, Haoxin Tu, Mehtab Zafar, Zhengxiong Luo, Abhik Roychoudhury

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

Content type: article

Language: en

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

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-workflow](<https://devfeed.tech/tags/agentic-workflow.md>), [api](<https://devfeed.tech/tags/api.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [environment](<https://devfeed.tech/tags/environment.md>), [formal](<https://devfeed.tech/tags/formal.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [functionality](<https://devfeed.tech/tags/functionality.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [harness](<https://devfeed.tech/tags/harness.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [library](<https://devfeed.tech/tags/library.md>), [linear](<https://devfeed.tech/tags/linear.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [orders](<https://devfeed.tech/tags/orders.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The paper argues that agentic verification is limited by what can be proved: existing approaches that prove a fuzz harness never crashes cover one API-call sequence in one context, not the library's full range of use. It proposes executable "verification harnesses" that model all legal API usages, aiming to make proofs apply to every well-behaved client. An agentic workflow extracts usage contracts from code and documentation, then uses Linear-time Temporal Logic to rule out illegal call orders. The authors identify challenges in proving these harnesses and release them as open-source challenges; routine library verification with broad client coverage is presented as a vision.

### Source excerpt

arXiv:2611.15207v1 Announce Type: new Abstract: LLM agents are making formal verification practical at scale. Recently, many attempts have raised this as an enticing possibility. However, formal verification at scale is only meaningful if deep formal specifications capturing functionality are available for checking. Unfortunately, recent works seek to bypass this issue by using shallow specifications devised for purposes other than verification. OSS-Verify from Anthropic and Theorem, for example, reuses the fuzz harnesses of open-source libraries as specifications and has an agent prove that each harness never crashes. However, a fuzz harness follows a single sequence of API calls under a single calling context, so the resulting proof covers one usage scenario rather than the library. We argue that the bottleneck of agentic verification has shifted from how to prove to what to prove. Before zooming into verification at scale, we need deep environment specifications to prove, which is why we call our effort Pre-QED. We propose verification harnesses, executable harnesses that model all legal usages of an API, so that a proof about the harness is a proof about every well-behaved client. To construct them, we use an agentic workflow that extracts the API's usage contract from code / documentation, and uses Linear-time Temporal Logic (LTL) to rule out illegal call orders. We identify the challenges in proving verification harnesses and release our harnesses open-source as challenges for the community. The overarching vision is that verifying an open-source library should become as routine as fuzzing it, with a guarantee that covers every well-behaved client rather than a single scenario like a fuzzing harness.

## Eliciting and Mitigating Specification Satisficing in Coding Agents

DevFeed: [Eliciting and Mitigating Specification Satisficing in Coding Agents](<https://devfeed.tech/articles/eliciting-and-mitigating-specification-satisficing-in-coding-agents-131731.md>)

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

Author: Ruixin Wang, Tianyi Zhang

Published: 2026-11-13T05: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: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Specifications](<https://devfeed.tech/topics/specifications.md>)

Tags: [ablation](<https://devfeed.tech/tags/ablation.md>), [agent-frameworks](<https://devfeed.tech/tags/agent-frameworks.md>), [agents](<https://devfeed.tech/tags/agents.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [deepswe](<https://devfeed.tech/tags/deepswe.md>), [llms](<https://devfeed.tech/tags/llms.md>), [requirements](<https://devfeed.tech/tags/requirements.md>), [specification](<https://devfeed.tech/tags/specification.md>), [swe-bench](<https://devfeed.tech/tags/swe-bench.md>), [swe-bench-pro](<https://devfeed.tech/tags/swe-bench-pro.md>)

### AI overview

Specification satisficing occurs when a coding agent notices an implementation choice that meets a task requirement but commits to a different, noncompliant choice it considers acceptable. SatisFix asks agents to report such choices and their reasons, then checks each against the task description. Across five LLM backbones and two agent frameworks, it raised base-agent pass@1 by an average of 5.09% on DeepSWE and 7.06% on SWE-bench Pro's hard subset; on DeepSWE it exceeded the strongest of three self-correction baselines by 3.98%. Ablations found that both reporting and checking contributed to the gains.

### Source excerpt

arXiv:2611.16289v1 Announce Type: new Abstract: Coding agents often fail to meet all requirements in the task description. In some of these failures, the agent considers an implementation choice that meets a requirement, but later decides to commit to another one that does not meet the requirement for a reason it finds acceptable. We call this specification satisficing. It is challenging to identify and mitigate specification satisficing because the agent accepts such choices for its own reasons, and existing self-correction methods are biased toward them. We propose SatisFix, which guides a coding agent to report these choices and their reasons, and then check each choice against the task description. We evaluate SatisFix on DeepSWE and SWE-bench Pro with five LLMs as backbones and two different agent frameworks, and compare it with three self-correction methods. SatisFix improves the pass@1 of the base agent by an average of 5.09% on DeepSWE and 7.06% on the hard subset of SWE-bench Pro. On DeepSWE, it outperforms the best baseline by 3.98%. Our ablation study shows that both steps of SatisFix contribute to the improvement.

## LLM-Assisted Verification in Dafny

DevFeed: [LLM-Assisted Verification in Dafny](<https://devfeed.tech/articles/llm-assisted-verification-in-dafny-131738.md>)

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

Author: Wieger Wesselink, Kees Huizing, Huub van de Wetering

Published: 2026-11-13T05: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: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [human review](<https://devfeed.tech/topics/human-review.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [claude-opus-5](<https://devfeed.tech/tags/claude-opus-5.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [graph-theory](<https://devfeed.tech/tags/graph-theory.md>), [human-oversight](<https://devfeed.tech/tags/human-oversight.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-assisted](<https://devfeed.tech/tags/llm-assisted.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The paper presents a ten-step workflow for using LLMs with Dafny to build machine-checked verifications of scientific algorithms. It combines algorithm formalization, contract and invariant development, proof construction, solver-feedback diagnosis, bottleneck profiling, and resource-driven optimization, with automated testing and verification feedback and human oversight of correctness-critical decisions. The authors report applying Claude Opus 5 and Opus 5.5 to 37 algorithms in graph theory and labelled transition systems, including the Hopcroft-Tarjan triconnectivity test. Many verifications took hours to a few days of interactive development. The authors suggest this approach shifts human effort toward supervision, specification review, and strategic guidance; the excerpt does not provide comparative results or detail the ten steps individually.

### Source excerpt

arXiv:2611.16886v1 Announce Type: cross Abstract: Formal verification of complex algorithms requires expertise in program specification, invariant construction, mathematical proof, and the management of automated theorem provers. Although large language models (LLMs) can generate program code and proof fragments, reliably developing complete machine-checked verifications remains challenging: it requires an iterative process of constructing and validating specifications and invariants, building proofs, diagnosing solver failures, and optimizing verification performance. This paper presents a systematic ten-step workflow for LLM-assisted verification of scientific algorithms using the Dafny verification system. The workflow integrates algorithm formalization, contract development, empirical invariant validation, proof construction, bottleneck profiling, and resource-driven proof optimization. We applied the workflow using Antrhopic's Claude Opus 5 and Opus 5.5 models, combining LLM-driven development with automated testing and verification feedback, while retaining human oversight for correctness-critical decisions and strategic interventions. We evaluate the approach on 37 complex algorithms from graph theory and labelled transition systems. Notably, we verified the Hopfcroft-Tarjan triconnectivity test, demonstrating that even highly challenging algorithmic verification tasks can be carried out through a structured LLM-assisted workflow. Many of our machine-checked verifications were obtained within hours to a few days of interactive development. Our results suggest that LLM-assisted workflows can shift the role of the human verifier from detailed proof construction toward supervision, specification review, and strategic guidance.

[Next page](<https://devfeed.tech/topics/spec-driven-development.md?cursor=WyIyMDI2LTExLTEzVDA1OjAwOjAwKzAwOjAwIiwgIjA0NzkxOTQwLWMwMjYtNDI5Yi1iN2MyLTE3MTYwYjAxNjA0ZCJd>)