<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: oleksoleks07</title>
    <description>The latest articles on DEV Community by oleksoleks07 (@oleksoleks07).</description>
    <link>https://dev.to/oleksoleks07</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4209133%2F727ba483-73ce-435e-87b8-6f4e83395a05.png</url>
      <title>DEV Community: oleksoleks07</title>
      <link>https://dev.to/oleksoleks07</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/oleksoleks07"/>
    <language>en</language>
    <item>
      <title>Your CI Pipeline Is Green. So Why Is Everyone Afraid to Release?</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Wed, 18 Nov 2026 18:22:37 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/your-ci-pipeline-is-green-so-why-is-everyone-afraid-to-release-6kf</link>
      <guid>https://dev.to/oleksoleks07/your-ci-pipeline-is-green-so-why-is-everyone-afraid-to-release-6kf</guid>
      <description>&lt;p&gt;A green CI badge is supposed to mean the team can merge with confidence.&lt;/p&gt;

&lt;p&gt;But ask the people who maintain the test suite a different question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Would you trust this pipeline enough to release on a Friday afternoon?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If the answer is “it depends,” your automation may be passing without actually providing confidence.&lt;/p&gt;

&lt;p&gt;A pipeline can be green while developers are rerunning tests, ignoring known failures, waiting too long for feedback, or quietly avoiding parts of the suite. The dashboard says success; the team’s behavior says otherwise.&lt;/p&gt;

&lt;p&gt;That gap is where QA automation health matters.&lt;/p&gt;

&lt;h2&gt;
  
  
  Green is a status, not a quality signal
&lt;/h2&gt;

&lt;p&gt;A passing build tells you that one execution completed successfully under one set of conditions. It does not tell you whether the result is repeatable, whether failures are diagnosable, or whether the suite protects the behavior that matters to users.&lt;/p&gt;

&lt;p&gt;I usually look for four warning signs:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Retries are normal.&lt;/strong&gt; A test fails, passes on retry, and the build is called successful. The failure disappears from the headline metric, but the instability remains.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The suite is slow enough to change behavior.&lt;/strong&gt; Developers batch changes, postpone running tests, or stop waiting for the full pipeline.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Failures are hard to explain.&lt;/strong&gt; A red build gives the team a symptom, not a useful route to the cause.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;People work around the suite.&lt;/strong&gt; They rerun jobs, skip tests, or ask someone who “knows the flaky ones” whether a failure can be ignored.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;None of these problems is solved by adding more tests.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Measure reliability, not just pass rate
&lt;/h2&gt;

&lt;p&gt;Pass rate is useful, but it is an incomplete measure when retries and quarantines are involved.&lt;/p&gt;

&lt;p&gt;Track a small set of signals together:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Signal&lt;/th&gt;
&lt;th&gt;What it tells you&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;First-run failure rate&lt;/td&gt;
&lt;td&gt;How often the suite fails before retries&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Retry rate&lt;/td&gt;
&lt;td&gt;How often a test needs another attempt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Flaky-test recurrence&lt;/td&gt;
&lt;td&gt;Whether the same tests keep failing inconsistently&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Median and P95 pipeline duration&lt;/td&gt;
&lt;td&gt;Typical feedback time and the slow tail&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Time to diagnose a failure&lt;/td&gt;
&lt;td&gt;How quickly the team can identify the cause&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Quarantined tests and age&lt;/td&gt;
&lt;td&gt;How much coverage is currently outside the normal gate&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The important part is to keep the definitions stable. If a retry turns a failure into a pass, preserve both facts in your reporting. Otherwise, the dashboard can make a noisy suite look healthy.&lt;/p&gt;

&lt;p&gt;Also segment the numbers. A single overall pass rate can hide one browser, environment, or test group that is responsible for most of the pain.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Fix isolation before increasing test volume
&lt;/h2&gt;

&lt;p&gt;Flaky tests often get blamed on the test runner. Sometimes the runner is involved, but recurring instability commonly comes from shared state and weak test boundaries.&lt;/p&gt;

&lt;p&gt;Look for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;shared accounts or records that tests modify concurrently;&lt;/li&gt;
&lt;li&gt;fixtures that leak state between tests;&lt;/li&gt;
&lt;li&gt;selectors coupled to layout or styling details;&lt;/li&gt;
&lt;li&gt;fixed sleeps where the test should wait for a meaningful condition;&lt;/li&gt;
&lt;li&gt;tests that depend on execution order;&lt;/li&gt;
&lt;li&gt;cleanup that runs only on the happy path.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For example, a fixed wait in Playwright is usually a warning sign:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;page&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;waitForTimeout&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;3000&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It says, “I hope the page is ready after three seconds.”&lt;/p&gt;

&lt;p&gt;Prefer waiting for the condition the test actually needs:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;expect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;page&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getByRole&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"heading"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"Dashboard"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
  &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;toBeVisible&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is not a universal cure for flaky tests. The application may still have race conditions, unstable data, or asynchronous behavior that needs to be fixed. But condition-based waits make the test’s expectation explicit and remove timing guesses.&lt;/p&gt;

&lt;p&gt;A useful rule: &lt;strong&gt;make each test responsible for its own setup, data, and cleanup wherever practical.&lt;/strong&gt; Parallel execution should reveal isolation problems, not create mysterious dependencies.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Make failures actionable
&lt;/h2&gt;

&lt;p&gt;A failure report should help an engineer answer three questions:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;What failed?&lt;/li&gt;
&lt;li&gt;What was the system doing at the time?&lt;/li&gt;
&lt;li&gt;What should I inspect next?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;For browser automation, that often means retaining the right evidence: error output, screenshots, traces, browser and environment details, and enough information to reproduce the run.&lt;/p&gt;

&lt;p&gt;Avoid collecting everything forever. Keep evidence that helps diagnose failures, set retention limits, and make sure secrets or personal data are not accidentally included in artifacts.&lt;/p&gt;

&lt;p&gt;A useful failure message is not merely:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Expected true, received false
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It should include the failed expectation, the relevant state, and a link to the trace or screenshot when available.&lt;/p&gt;

&lt;p&gt;The goal is to reduce the time between “the pipeline is red” and “we know why.”&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Treat CI duration as an engineering constraint
&lt;/h2&gt;

&lt;p&gt;A slow pipeline changes how people work.&lt;/p&gt;

&lt;p&gt;Start by measuring median and P95 duration for the whole pipeline and its major stages. Then identify where time is actually spent:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;dependency installation;&lt;/li&gt;
&lt;li&gt;environment provisioning;&lt;/li&gt;
&lt;li&gt;test startup and teardown;&lt;/li&gt;
&lt;li&gt;browser or service startup;&lt;/li&gt;
&lt;li&gt;repeated work that could be cached safely;&lt;/li&gt;
&lt;li&gt;tests that can run independently in parallel.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Be careful with parallelism. Increasing workers can make a suite slower if tests compete for the same database, accounts, CPU, or external services. Measure the effect rather than assuming more workers means faster feedback.&lt;/p&gt;

&lt;p&gt;A practical improvement is to separate fast feedback from broader confidence:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;run linting, unit tests, and a small critical smoke suite on every change;&lt;/li&gt;
&lt;li&gt;run broader integration and end-to-end coverage at an appropriate stage;&lt;/li&gt;
&lt;li&gt;keep scheduled or pre-release suites for checks that are too expensive for every commit.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The exact split depends on the product. The principle is to give developers useful feedback quickly without pretending that a small smoke suite replaces full regression coverage.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. A four-week path to a more trustworthy suite
&lt;/h2&gt;

&lt;p&gt;You do not need to rebuild your automation framework to make progress. A focused sequence is often more effective.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Week 1 — Establish a baseline&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Measure first-run failures, retries, flaky recurrence, and pipeline duration.&lt;/li&gt;
&lt;li&gt;Identify the tests responsible for the most repeated failures.&lt;/li&gt;
&lt;li&gt;Record which tests are quarantined and why.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Week 2 — Remove the biggest sources of instability&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Fix shared test data and fixture leakage.&lt;/li&gt;
&lt;li&gt;Replace arbitrary sleeps with condition-based waits.&lt;/li&gt;
&lt;li&gt;Make cleanup reliable, including after failures.&lt;/li&gt;
&lt;li&gt;Assign an owner to recurring flaky tests.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Week 3 — Improve diagnosis and feedback&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Add or tune traces, screenshots, and useful logs.&lt;/li&gt;
&lt;li&gt;Make failure reports easy to find from the CI job.&lt;/li&gt;
&lt;li&gt;Split fast checks from slower regression coverage where it makes sense.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Week 4 — Make ownership sustainable&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Agree on what qualifies as flaky and when a test may be quarantined.&lt;/li&gt;
&lt;li&gt;Set an owner and review date for every quarantined test.&lt;/li&gt;
&lt;li&gt;Review the baseline with the team and choose the next two or three improvements.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The objective is not a perfect dashboard. It is a suite that gives the team evidence they can act on.&lt;/p&gt;

&lt;h2&gt;
  
  
  Before buying another testing tool, inspect the system you already have
&lt;/h2&gt;

&lt;p&gt;When a team is struggling with automation, it is tempting to add another framework, reporting service, or orchestration layer.&lt;/p&gt;

&lt;p&gt;Sometimes a new tool is the right answer. But first, understand the current system: test architecture, data isolation, CI configuration, failure reporting, and ownership.&lt;/p&gt;

&lt;p&gt;That is the thinking behind &lt;a href="https://qahealthcheck.online/" rel="noopener noreferrer"&gt;QA Health Check&lt;/a&gt;, a service for smaller SaaS and product engineering teams. It reviews one automation repository and one main CI pipeline, then provides a prioritized view of risks, practical quick wins, and a 30-day improvement plan. The aim is to help a team decide what to fix first—not to sell a framework rewrite.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Disclosure: I'm associated with QA Health Check. I’m mentioning it because it focuses on the same automation reliability and CI problems discussed in this article.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The real question
&lt;/h2&gt;

&lt;p&gt;A mature automation suite is not the one with the most tests or the greenest badge. It is the one developers trust enough to use when making a release decision.&lt;/p&gt;

&lt;p&gt;So, what is the biggest obstacle in your current setup: flaky tests, slow pipelines, hard-to-diagnose failures, or a lack of clear ownership?&lt;/p&gt;

&lt;p&gt;I’d be interested to hear what has helped your team move from “the build passed” to “we trust this result.”&lt;/p&gt;

</description>
      <category>testing</category>
      <category>devops</category>
      <category>qa</category>
      <category>programming</category>
    </item>
    <item>
      <title>TypeScript 7.1 Has a New API. Your Tooling Might Not Be Ready Yet.</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Mon, 16 Nov 2026 14:13:33 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/typescript-71-has-a-new-api-your-tooling-might-not-be-ready-yet-2hpg</link>
      <guid>https://dev.to/oleksoleks07/typescript-71-has-a-new-api-your-tooling-might-not-be-ready-yet-2hpg</guid>
      <description>&lt;p&gt;TypeScript 7.0 brought a native compiler and dramatic build-time improvements. But there was a catch: &lt;strong&gt;7.0 did not expose a programmatic API&lt;/strong&gt;. That mattered to tools that need to inspect TypeScript programs, build language services, or understand code inside files such as &lt;code&gt;.vue&lt;/code&gt; and &lt;code&gt;.svelte&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;TypeScript 7.1 Beta, announced on October 20, changes that picture. It introduces a new modular API and a plugin point called &lt;em&gt;content mappers&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;That is useful news — but it is not a reason to upgrade every repository blindly. The API is new, the ecosystem is still catching up, and some of the new extension points execute external code.&lt;/p&gt;

&lt;p&gt;Here is what changed and how I would evaluate it in a real project.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. The API is new, not just the old API with a new version number
&lt;/h2&gt;

&lt;p&gt;TypeScript 7.1 splits its API into focused entry points:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Entry point&lt;/th&gt;
&lt;th&gt;What it is for&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;typescript/sync&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Synchronous compiler, program, and type-checker APIs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;typescript/async&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Promise-based compiler API&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;typescript/fs&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Filesystem abstractions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;typescript/ast&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;AST types and enums&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;typescript/ast/is&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;AST type guards&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;code&gt;typescript/ast/factory&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;AST node creation and immutable updates&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This is a different surface from the familiar monolithic TypeScript compiler API. Tool authors should read the migration guidance rather than assume that changing the package version is enough.&lt;/p&gt;

&lt;p&gt;The official announcement includes the API overview and examples: &lt;a href="https://devblogs.microsoft.com/typescript/announcing-typescript-7-1-beta/" rel="noopener noreferrer"&gt;Announcing TypeScript 7.1 Beta&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. A small compiler API example
&lt;/h2&gt;

&lt;p&gt;The new synchronous API can compile an explicit set of files and collect diagnostics:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="no"&gt;API&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="n"&gt;formatDiagnosticsWithColorAndContext&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;Diagnostic&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="s2"&gt;"typescript/sync"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="n"&gt;using&lt;/span&gt; &lt;span class="n"&gt;api&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="no"&gt;API&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;reportErrors&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;diagnostics&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="k"&gt;readonly&lt;/span&gt; &lt;span class="nc"&gt;Diagnostic&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nb"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;formatDiagnosticsWithColorAndContext&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;diagnostics&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;api&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;slice&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;parsed&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;api&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;parseCommandLine&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;parsed&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;errors&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;length&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nf"&gt;reportErrors&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;parsed&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;errors&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;exitCode&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="n"&gt;using&lt;/span&gt; &lt;span class="n"&gt;program&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;api&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;createProgram&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;parsed&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;fileNames&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;parsed&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;options&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;diagnostics&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;program&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getGlobalDiagnostics&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;program&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getProgramDiagnostics&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;program&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getSyntacticDiagnostics&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;program&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;getSemanticDiagnostics&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;diagnostics&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;length&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nf"&gt;reportErrors&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;diagnostics&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;exitCode&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;emitted&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;program&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;emit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

  &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;emitted&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;diagnostics&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;length&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nf"&gt;reportErrors&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;emitted&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;diagnostics&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nb"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;exitCode&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;There is an important detail here: the API and program objects are disposable. TypeScript 7.1 uses &lt;code&gt;using&lt;/code&gt; in its examples so resources are released when the scope ends.&lt;/p&gt;

&lt;p&gt;That is not cosmetic syntax. The implementation crosses the Go and JavaScript runtimes, so failing to dispose objects can retain resources on the Go side. If you build a long-running language tool, compiler service, or watch process, lifecycle management belongs in your design from day one.&lt;/p&gt;

&lt;p&gt;Also note the boundary of this example: it compiles the filenames and options you pass. It does not automatically discover a project through &lt;code&gt;--project&lt;/code&gt; in the same way as the &lt;code&gt;tsc&lt;/code&gt; command.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Content mappers make framework files visible to TypeScript
&lt;/h2&gt;

&lt;p&gt;A second change may matter even more to web developers.&lt;/p&gt;

&lt;p&gt;Framework files often mix HTML, CSS, and TypeScript in one file. Vue, Svelte, Astro, and MDX tooling has historically needed custom integration to map those embedded regions into something TypeScript can understand.&lt;/p&gt;

&lt;p&gt;TypeScript 7.1 introduces &lt;strong&gt;content mappers&lt;/strong&gt;. A mapper can provide a virtual representation of a file, along with mappings back to the original source. That gives diagnostics and editor features a better way to point to the actual code developers wrote.&lt;/p&gt;

&lt;p&gt;A simplified configuration looks like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"compilerOptions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nl"&gt;"contentMappers"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
      &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nl"&gt;"package"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"@example/vue-content-mapper"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nl"&gt;"extensions"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;".vue"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nl"&gt;"options"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
          &lt;span class="nl"&gt;"target"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mf"&gt;3.5&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
      &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;]&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The package name above is illustrative — it is not a recommendation to install a package with that name.&lt;/p&gt;

&lt;p&gt;There is also a security boundary worth noticing: content mappers are executable code. The CLI requires the explicit &lt;code&gt;--runExternalCode&lt;/code&gt; flag to run them. In VS Code, workspace trust and content-mapper permissions also matter.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do not enable external mappers in an untrusted repository just to make diagnostics appear.&lt;/strong&gt; Pin the dependency, review what it executes, and make the permission decision explicit in local development and CI.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. A practical adoption checklist
&lt;/h2&gt;

&lt;p&gt;I would introduce TypeScript 7.1 in stages:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Inventory API consumers.&lt;/strong&gt; Search your dependencies and build scripts for imports from &lt;code&gt;typescript&lt;/code&gt;, compiler API usage, language-service plugins, and framework integrations.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Create a migration branch.&lt;/strong&gt; Install the beta explicitly with &lt;code&gt;npm install -D typescript@beta&lt;/code&gt; and commit the lockfile. Do not make a floating beta dependency part of a production build.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Separate the CLI from tooling integrations.&lt;/strong&gt; A project may be able to use the new compiler while a linter, test transformer, editor plugin, or framework integration still expects an older API.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Port one integration at a time.&lt;/strong&gt; Start with a small tool that uses a narrow part of the API. Avoid rewriting the compiler, linter, test runner, and editor integration in one change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Test resource cleanup.&lt;/strong&gt; Exercise repeated compilations and watch updates. Make sure every API, program, and snapshot has a clear lifetime and is disposed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Treat content mappers as plugins.&lt;/strong&gt; Pin versions, review permissions, test workspace-trust behavior, and keep external-code execution disabled unless the repository is trusted.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Compare the whole workflow.&lt;/strong&gt; Run type-checking, tests, lint, framework checks, and production builds. Measure editor responsiveness and CI time too — a faster &lt;code&gt;tsc&lt;/code&gt; command does not prove the complete toolchain is faster.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  5. What I would not assume yet
&lt;/h2&gt;

&lt;p&gt;TypeScript 7.1 is a beta release. The new API is a meaningful step, but that does not mean every framework, test runner, bundler, or editor extension has already migrated.&lt;/p&gt;

&lt;p&gt;The TypeScript team describes the API as an evolving surface and says more examples are coming. Check the compatibility status of the exact tools in your stack before making the new compiler your only option.&lt;/p&gt;

&lt;p&gt;For background on the native compiler and the 7.0 transition, see the &lt;a href="https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/" rel="noopener noreferrer"&gt;TypeScript 7.0 announcement&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;TypeScript 7.1 is more than another compiler speed release. The API and content-mapper work could make it easier for the ecosystem to build better framework-aware tools — but it also asks tool authors to think carefully about object lifetimes, compatibility, and executable extensions.&lt;/p&gt;

&lt;p&gt;If you maintain a TypeScript tool or a web application, &lt;strong&gt;which integration would you want to see adopt the new API first: ESLint, test runners, bundlers, or Vue/Svelte/Astro tooling?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>typescript</category>
      <category>devtools</category>
      <category>webdev</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>A Git Worktree Is Not an Agent Sandbox</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Fri, 13 Nov 2026 13:52:22 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/a-git-worktree-is-not-an-agent-sandbox-2i4o</link>
      <guid>https://dev.to/oleksoleks07/a-git-worktree-is-not-an-agent-sandbox-2i4o</guid>
      <description>&lt;h1&gt;
  
  
  A Git Worktree Is Not an Agent Sandbox
&lt;/h1&gt;

&lt;p&gt;On November 10, Google announced &lt;strong&gt;/swarm&lt;/strong&gt; for Antigravity: a multi-agent workflow that gives parallel workers isolated Git worktrees and uses separate verifiers to challenge their changes. Anthropic has also announced newer models aimed at longer, more complex technical work.&lt;/p&gt;

&lt;p&gt;The direction is clear: developers are moving from asking one assistant to complete a task toward coordinating several agents.&lt;/p&gt;

&lt;p&gt;But there is a trap in the word &lt;em&gt;isolated&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;A Git worktree isolates a checkout and a branch. It does &lt;strong&gt;not&lt;/strong&gt; automatically isolate the database, Redis instance, ports, test accounts, API quotas, queues, credentials, or cloud resources those agents use.&lt;/p&gt;

&lt;p&gt;You can have three agents in three clean worktrees and still have them break each other's environment.&lt;/p&gt;

&lt;p&gt;The useful mental model is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;A worktree isolates files. A reliable agent workflow must isolate resources and ownership too.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  1. Start with one worktree per independent task
&lt;/h2&gt;

&lt;p&gt;Worktrees are still a good foundation. They let multiple branches have separate working directories without cloning the repository's entire Git history.&lt;/p&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git worktree add ../app-agent-auth -b agent/auth
git worktree add ../app-agent-export -b agent/export

git worktree list
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Now each agent has its own checkout. One can work on authentication while another builds an export feature.&lt;/p&gt;

&lt;p&gt;That prevents the most obvious collision: two processes editing the same working tree.&lt;/p&gt;

&lt;p&gt;It does not prevent either process from connecting to the same local Postgres database.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Give every agent its own runtime resources
&lt;/h2&gt;

&lt;p&gt;Imagine agent A runs a migration that renames a database column. Agent B is halfway through an integration test that expects the old column.&lt;/p&gt;

&lt;p&gt;Their files are separate. Their database is not.&lt;/p&gt;

&lt;p&gt;The same class of problem appears with:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;a shared Redis cache or queue;&lt;/li&gt;
&lt;li&gt;two development servers trying to use the same port;&lt;/li&gt;
&lt;li&gt;a shared test account whose state one agent resets;&lt;/li&gt;
&lt;li&gt;generated files written to one common directory;&lt;/li&gt;
&lt;li&gt;a rate-limited sandbox API called by several agents;&lt;/li&gt;
&lt;li&gt;one agent changing a shared schema while another builds against it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For local development, assign a small resource namespace to each worktree:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Resource&lt;/th&gt;
&lt;th&gt;Agent 1&lt;/th&gt;
&lt;th&gt;Agent 2&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Dev server&lt;/td&gt;
&lt;td&gt;Port 3101&lt;/td&gt;
&lt;td&gt;Port 3102&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Test database&lt;/td&gt;
&lt;td&gt;app_agent_1&lt;/td&gt;
&lt;td&gt;app_agent_2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Redis prefix&lt;/td&gt;
&lt;td&gt;agent_1:&lt;/td&gt;
&lt;td&gt;agent_2:&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Storage prefix&lt;/td&gt;
&lt;td&gt;agent-1/&lt;/td&gt;
&lt;td&gt;agent-2/&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Test tenant&lt;/td&gt;
&lt;td&gt;qa-agent-1&lt;/td&gt;
&lt;td&gt;qa-agent-2&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The values are examples; use the names and isolation mechanisms your stack supports.&lt;/p&gt;

&lt;p&gt;Keep per-agent configuration outside tracked files. Do not copy production credentials into every worktree. Give agents short-lived, least-privilege credentials for test environments only.&lt;/p&gt;

&lt;p&gt;If a service cannot be separated, treat it as a shared resource and coordinate access rather than pretending it is isolated.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Use a resource contract, not just a prompt
&lt;/h2&gt;

&lt;p&gt;Before starting an agent, write down what it owns and what it must not touch.&lt;/p&gt;

&lt;p&gt;A useful task card can be as small as this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;task&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;add CSV export&lt;/span&gt;
&lt;span class="na"&gt;worktree&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;../app-agent-export&lt;/span&gt;
&lt;span class="na"&gt;branch&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;agent/export&lt;/span&gt;

&lt;span class="na"&gt;owns&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s"&gt;src/export/**&lt;/span&gt;

&lt;span class="na"&gt;read_only&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s"&gt;src/api/contracts/**&lt;/span&gt;

&lt;span class="na"&gt;do_not_edit&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s"&gt;db/schema.prisma&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s"&gt;package-lock.json&lt;/span&gt;

&lt;span class="na"&gt;resources&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3102&lt;/span&gt;
  &lt;span class="na"&gt;database&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;app_agent_2&lt;/span&gt;
  &lt;span class="na"&gt;storage_prefix&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;agent-2/&lt;/span&gt;

&lt;span class="na"&gt;acceptance&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s"&gt;export unit tests pass&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s"&gt;no changes outside owned paths without approval&lt;/span&gt;
  &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="s"&gt;report commands actually executed&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is a task contract, not a universal configuration format. Its job is to make boundaries explicit before the agent starts changing things.&lt;/p&gt;

&lt;p&gt;For tasks that need the same schema, lockfile, migration, or central configuration, assign one owner. Other agents can work against an agreed interface, but they should not independently rewrite the shared contract.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Serialize the parts that are genuinely shared
&lt;/h2&gt;

&lt;p&gt;Not every task benefits from parallel execution.&lt;/p&gt;

&lt;p&gt;Good candidates:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;add a feature in a separate module;&lt;/li&gt;
&lt;li&gt;write documentation for an already stable API;&lt;/li&gt;
&lt;li&gt;build an independent UI component;&lt;/li&gt;
&lt;li&gt;add tests for a defined interface.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Keep these serial unless you have a deliberate coordination mechanism:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;database migrations;&lt;/li&gt;
&lt;li&gt;dependency lockfile updates;&lt;/li&gt;
&lt;li&gt;shared API or event schema changes;&lt;/li&gt;
&lt;li&gt;edits to the same central file;&lt;/li&gt;
&lt;li&gt;operations against one stateful external test account.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For external APIs with strict rate limits, use a queue or semaphore with a known concurrency limit. Giving every agent the same API key does not create more quota; it creates a race for the same quota.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Integrate one change at a time
&lt;/h2&gt;

&lt;p&gt;A coordinator should not merge every agent's output at once.&lt;/p&gt;

&lt;p&gt;A safer loop is:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Ask each agent for a concise summary, changed-file list, test commands, and unresolved risks.&lt;/li&gt;
&lt;li&gt;Inspect the diff against the agreed task contract.&lt;/li&gt;
&lt;li&gt;Merge one branch.&lt;/li&gt;
&lt;li&gt;Run the relevant tests against the combined state.&lt;/li&gt;
&lt;li&gt;Only then merge the next branch.&lt;/li&gt;
&lt;li&gt;Remove the worktree when its work is accepted.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;A separate verifier can challenge assumptions and run tests, but it is not a substitute for reviewing the integrated result.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Measure whether parallelism is actually helping
&lt;/h2&gt;

&lt;p&gt;More agents do not automatically mean faster delivery. Coordination, repeated setup, merge conflicts, test collisions, and model usage all have a cost. Google also notes that its multi-agent workflow can consume quota much faster than a standard chat.&lt;/p&gt;

&lt;p&gt;Start with two agents, not ten.&lt;/p&gt;

&lt;p&gt;Track a few simple signals:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;time from task start to an accepted change;&lt;/li&gt;
&lt;li&gt;time spent resolving integration conflicts;&lt;/li&gt;
&lt;li&gt;failed tests caused by shared state;&lt;/li&gt;
&lt;li&gt;repeated work or overwritten changes;&lt;/li&gt;
&lt;li&gt;total model and infrastructure cost.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If the integration and rework time exceeds the time saved, split the work differently—or do it sequentially.&lt;/p&gt;

&lt;h2&gt;
  
  
  A short pre-flight checklist
&lt;/h2&gt;

&lt;p&gt;Before launching parallel agents, check:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;[ ] Each agent has a separate worktree and branch.&lt;/li&gt;
&lt;li&gt;[ ] Each task has clear file ownership and acceptance criteria.&lt;/li&gt;
&lt;li&gt;[ ] Ports, databases, caches, queues, and storage are separated or coordinated.&lt;/li&gt;
&lt;li&gt;[ ] Credentials are scoped to test resources.&lt;/li&gt;
&lt;li&gt;[ ] Shared schemas, migrations, and lockfiles have one owner.&lt;/li&gt;
&lt;li&gt;[ ] Changes will be reviewed and integrated one at a time.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Google's &lt;a href="https://antigravity.google/blog/gemini-4-carbon-in-google-antigravity" rel="noopener noreferrer"&gt;Antigravity /swarm announcement&lt;/a&gt; is an interesting signal of where developer tooling is heading. The lesson for an ordinary team is not that everyone needs a swarm. It is that concurrency needs explicit boundaries.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A worktree gives an agent its own desk. It does not give it its own database, API quota, or authority.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;When you run multiple coding agents, what has caused the most trouble for your team: file conflicts, shared runtime resources, unclear task ownership, or integration review?&lt;/p&gt;

</description>
      <category>ai</category>
      <category>git</category>
      <category>devtools</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Your Team Doesn't Need a Platform Team. It Needs One Golden Path.</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Wed, 11 Nov 2026 13:25:19 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/your-team-doesnt-need-a-platform-team-it-needs-one-golden-path-3kna</link>
      <guid>https://dev.to/oleksoleks07/your-team-doesnt-need-a-platform-team-it-needs-one-golden-path-3kna</guid>
      <description>&lt;h1&gt;
  
  
  Your Team Doesn't Need a Platform Team. It Needs One Golden Path.
&lt;/h1&gt;

&lt;p&gt;A five-person engineering team does not need to copy the internal developer platform of a company with five hundred engineers.&lt;/p&gt;

&lt;p&gt;It probably does need one reliable answer to a few everyday questions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;How do I start this service locally?&lt;/li&gt;
&lt;li&gt;How do I run the same checks CI runs?&lt;/li&gt;
&lt;li&gt;Where do I put configuration and secrets?&lt;/li&gt;
&lt;li&gt;What must be true before a change can merge?&lt;/li&gt;
&lt;li&gt;If the service breaks, where is the runbook?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;When every repository answers those questions differently, developers spend time learning the team's accidental infrastructure instead of improving the product.&lt;/p&gt;

&lt;p&gt;The first useful platform is often not a portal, a Kubernetes cluster, or a new team. It is a &lt;strong&gt;golden path&lt;/strong&gt;: a small, documented, maintained default that makes the safe and common thing the easy thing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this matters now
&lt;/h2&gt;

&lt;p&gt;The CNCF and SlashData &lt;em&gt;State of Cloud Native Development Q3 2026&lt;/em&gt; report, published on November 10, estimates 21.2 million cloud-native developers worldwide. It says 75% of cloud-native developers use AI coding tools, compared with 55% of non-cloud-native developers. It also reports that 93% of developers work in organizations using DevOps standardization or internal developer platforms.&lt;/p&gt;

&lt;p&gt;That last figure combines standardization and internal platforms; it does &lt;strong&gt;not&lt;/strong&gt; mean 93% of companies have a dedicated platform team.&lt;/p&gt;

&lt;p&gt;The useful signal is simpler: as more code can be produced quickly, teams need repeatable ways to build, test, review, and operate it. A golden path gives a small team some of that consistency without introducing a platform project of its own.&lt;/p&gt;

&lt;p&gt;Source: &lt;a href="https://www.cncf.io/reports/the-state-of-cloud-native-development-q3-2026/" rel="noopener noreferrer"&gt;CNCF — The State of Cloud Native Development Q3 2026&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with one repeated source of friction
&lt;/h2&gt;

&lt;p&gt;Do not begin by asking, "Which platform should we buy?"&lt;/p&gt;

&lt;p&gt;Ask the team to name the three things that waste time in almost every repository. Typical answers are:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Different setup instructions and missing local dependencies.&lt;/li&gt;
&lt;li&gt;Different test and lint commands, or checks that only work in CI.&lt;/li&gt;
&lt;li&gt;Unclear ownership when a deployment or scheduled job fails.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Pick the most frequent problem. A golden path should remove a real recurring interruption, not create a generic abstraction.&lt;/p&gt;

&lt;h2&gt;
  
  
  A small golden path can fit in one repository
&lt;/h2&gt;

&lt;p&gt;For a typical Node service, a useful starting structure might be:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;service/
├── .github/
│   └── workflows/
│       └── ci.yml
├── docs/
│   └── runbook.md
├── .env.example
├── Makefile
├── package.json
└── README.md
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The exact files matter less than the contract they establish.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Give developers one local interface
&lt;/h3&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight make"&gt;&lt;code&gt;&lt;span class="nl"&gt;.PHONY&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; setup dev &lt;span class="nb"&gt;test&lt;/span&gt; lint check

&lt;span class="nl"&gt;setup&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    npm ci

&lt;span class="nl"&gt;dev&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    npm run dev

&lt;span class="nl"&gt;test&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    npm &lt;span class="nb"&gt;test&lt;/span&gt;

&lt;span class="nl"&gt;lint&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
    npm run lint

&lt;span class="nl"&gt;check&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; lint &lt;span class="nb"&gt;test&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Now a new developer does not need to remember five different commands. The README can say:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;cp .env.example .env
make setup
make dev
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Keep &lt;code&gt;.env.example&lt;/code&gt; limited to variable names and safe placeholders. Never put real credentials in it.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Make CI use the same contract
&lt;/h3&gt;

&lt;p&gt;A minimal GitHub Actions workflow can call the same &lt;code&gt;make check&lt;/code&gt; target:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;verify&lt;/span&gt;

&lt;span class="na"&gt;on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;pull_request&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;push&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;branches&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;main&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="na"&gt;jobs&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;checks&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;runs-on&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;ubuntu-latest&lt;/span&gt;
    &lt;span class="na"&gt;steps&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/checkout@v4&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;uses&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;actions/setup-node@v4&lt;/span&gt;
        &lt;span class="na"&gt;with&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
          &lt;span class="na"&gt;node-version&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt;
          &lt;span class="na"&gt;cache&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;make setup&lt;/span&gt;
      &lt;span class="p"&gt;-&lt;/span&gt; &lt;span class="na"&gt;run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s"&gt;make check&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is a teaching example, not a complete production security policy. For production workflows, review and pin third-party actions to verified commit SHAs, define supported Node versions explicitly, and keep deployment credentials out of pull-request jobs from untrusted forks.&lt;/p&gt;

&lt;p&gt;The important design choice is that local development and CI share the same entry points. If CI needs a secret or a service that cannot run locally, document that difference rather than pretending the environments are identical.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Put the operational answer next to the code
&lt;/h3&gt;

&lt;p&gt;A short &lt;code&gt;docs/runbook.md&lt;/code&gt; should answer:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What does this service depend on?&lt;/li&gt;
&lt;li&gt;How do we check whether it is healthy?&lt;/li&gt;
&lt;li&gt;Where are logs and dashboards?&lt;/li&gt;
&lt;li&gt;Who owns the service?&lt;/li&gt;
&lt;li&gt;What is the safest rollback?&lt;/li&gt;
&lt;li&gt;Which actions require approval?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A runbook is part of the developer experience. A green build does not help much if nobody knows what to do after deployment.&lt;/p&gt;

&lt;h2&gt;
  
  
  Add guardrails, not bureaucracy
&lt;/h2&gt;

&lt;p&gt;A golden path should make the safe default easy while leaving a documented escape hatch.&lt;/p&gt;

&lt;p&gt;For a small team, start with these rules:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Every service has a named owner.&lt;/li&gt;
&lt;li&gt;Every pull request runs the same baseline checks.&lt;/li&gt;
&lt;li&gt;Secrets are injected by the runtime or CI secret store, never committed.&lt;/li&gt;
&lt;li&gt;Deployments have a documented rollback path.&lt;/li&gt;
&lt;li&gt;Exceptions explain why the default does not fit and who accepted the trade-off.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Do not require a platform committee to approve every harmless variation. The goal is fewer surprises, not less autonomy.&lt;/p&gt;

&lt;h2&gt;
  
  
  Know whether the path is helping
&lt;/h2&gt;

&lt;p&gt;Avoid measuring success by the number of templates or YAML files created.&lt;/p&gt;

&lt;p&gt;Track a few outcomes instead:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Signal&lt;/th&gt;
&lt;th&gt;What it tells you&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Time to first successful local run&lt;/td&gt;
&lt;td&gt;How quickly a new developer becomes productive&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Time from PR creation to first green check&lt;/td&gt;
&lt;td&gt;Whether the shared workflow is predictable&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Repeated setup questions&lt;/td&gt;
&lt;td&gt;Whether documentation and defaults are clear&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Failed deploys and rollback time&lt;/td&gt;
&lt;td&gt;Whether the operational path is safe&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Exceptions to the template&lt;/td&gt;
&lt;td&gt;Whether the golden path fits real work&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Take a baseline before changing anything. Review the numbers after a few weeks and ask developers where the path still creates friction.&lt;/p&gt;

&lt;h2&gt;
  
  
  When should you build more?
&lt;/h2&gt;

&lt;p&gt;Only add another layer when the same problem appears across several services.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;If teams keep copying the same workflow, publish a reusable workflow.&lt;/li&gt;
&lt;li&gt;If service creation is repetitive, create a small repository template.&lt;/li&gt;
&lt;li&gt;If ownership and service metadata are hard to discover, consider a catalog.&lt;/li&gt;
&lt;li&gt;If teams need self-service infrastructure, automate one well-understood request before building a general portal.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Kubernetes, Backstage, and a dedicated platform team can be valuable. They are not the starting requirement for every organization.&lt;/p&gt;

&lt;h2&gt;
  
  
  The point is a calmer engineering day
&lt;/h2&gt;

&lt;p&gt;AI tools can make implementation faster, but they do not automatically make a codebase easier to run or a team easier to onboard. Without shared defaults, faster output can simply create more variation for the next developer to understand.&lt;/p&gt;

&lt;p&gt;Start with one golden path. Keep it boring, documented, and easy to improve. Let repeated pain—not platform fashion—tell you when it is time to build more.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the one setup, testing, or deployment task your team repeats differently in every repository?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>devops</category>
      <category>productivity</category>
      <category>tutorial</category>
      <category>architecture</category>
    </item>
    <item>
      <title>AI Can Generate the Tests. QA Still Has to Define “Correct.”</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Mon, 09 Nov 2026 13:21:42 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/ai-can-generate-the-tests-qa-still-has-to-define-correct-3coo</link>
      <guid>https://dev.to/oleksoleks07/ai-can-generate-the-tests-qa-still-has-to-define-correct-3coo</guid>
      <description>&lt;h1&gt;
  
  
  AI Can Generate the Tests. QA Still Has to Define “Correct.”
&lt;/h1&gt;

&lt;p&gt;An AI coding agent can generate twenty tests before you finish your coffee. It can add edge cases, run the suite, and report a green check.&lt;/p&gt;

&lt;p&gt;But there is a question those green checks cannot answer on their own:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Who decided what the correct behavior was?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If the requirement is ambiguous, an AI can produce a large, convincing test suite that verifies the wrong interpretation. More tests do not fix a missing definition of quality.&lt;/p&gt;

&lt;p&gt;This is becoming a practical QA problem, not a distant prediction about the future of testing.&lt;/p&gt;

&lt;h2&gt;
  
  
  The testing gap is already visible
&lt;/h2&gt;

&lt;p&gt;Two 2026 industry surveys point to the same tension: AI is spreading through development and testing, while teams are still struggling to keep quality controls aligned with the speed.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;SmartBear's &lt;em&gt;2026 State of Software Quality and Testing&lt;/em&gt; surveyed 1,436 US and UK practitioners and leaders using AI in development. It found that 46% of teams had shipped AI-written code that later failed in production. Only 46% said they validate the specification before AI generates code. &lt;a href="https://smartbear.com/news/news-releases/state-of-software-quality-testing-2026/" rel="noopener noreferrer"&gt;SmartBear, September 30, 2026&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;Applause's &lt;em&gt;2026 State of Digital Quality&lt;/em&gt; reported that more than 92% of respondents use AI in testing, while 29% said the number or severity of defects had increased. 86% considered human involvement extremely important to functional testing. &lt;a href="https://www.businesswire.com/news/home/20260930422160/en/" rel="noopener noreferrer"&gt;Applause, September 30, 2026&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These are industry surveys, not controlled experiments, and they do not prove AI caused every defect. They do show that generating and running tests is not the same as establishing that a product behaves correctly.&lt;/p&gt;

&lt;p&gt;A review published on November 5, 2026, synthesizing 113 peer-reviewed studies, also identifies semantic correctness, non-deterministic outputs, maintainability, verification, and evaluation consistency as persistent challenges in generative-AI software engineering. &lt;a href="https://doi.org/10.53941/jetia.2026.100010" rel="noopener noreferrer"&gt;Yang Lu, &lt;em&gt;Generative AI for Software Engineering&lt;/em&gt;, 2026&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The missing piece: a test oracle
&lt;/h2&gt;

&lt;p&gt;A test oracle is the source of truth that tells us what the expected result should be.&lt;/p&gt;

&lt;p&gt;Consider this requirement:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Apply a 10% discount to orders over $100.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;An agent can turn that sentence into tests immediately. But it still has to guess:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Is the threshold strictly greater than $100, or greater than or equal to $100?&lt;/li&gt;
&lt;li&gt;Is the discount calculated before tax and shipping?&lt;/li&gt;
&lt;li&gt;Can a coupon be combined with another promotion?&lt;/li&gt;
&lt;li&gt;How should the result be rounded?&lt;/li&gt;
&lt;li&gt;What happens if the order contains an excluded item?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If the agent guesses differently from the product owner, the tests may pass while the product is wrong.&lt;/p&gt;

&lt;p&gt;Before asking AI to generate tests, turn the requirement into observable rules.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Acceptance contract&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The threshold is evaluated against the eligible item subtotal before tax and shipping.&lt;/li&gt;
&lt;li&gt;The discount applies only when that subtotal is greater than $100.00.&lt;/li&gt;
&lt;li&gt;The discount is 10% of the eligible subtotal.&lt;/li&gt;
&lt;li&gt;The discount is rounded to two decimal places using the product's documented rounding rule.&lt;/li&gt;
&lt;li&gt;Shipping is calculated separately.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Now the boundary is explicit. The test suite has something independent to check against.&lt;/p&gt;

&lt;h2&gt;
  
  
  A small example: test the boundary, not the implementation
&lt;/h2&gt;

&lt;p&gt;Here is a simple pytest example. The expected values come from the acceptance contract, not from asking the AI what its own code should return.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;decimal&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;Decimal&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;pytest&lt;/span&gt;

&lt;span class="nd"&gt;@pytest.mark.parametrize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;subtotal&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;expected_discount&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="p"&gt;[&lt;/span&gt;
        &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Decimal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;99.99&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nc"&gt;Decimal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;0.00&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)),&lt;/span&gt;
        &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Decimal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;100.00&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nc"&gt;Decimal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;0.00&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)),&lt;/span&gt;
        &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Decimal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;100.01&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt; &lt;span class="nc"&gt;Decimal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;10.00&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)),&lt;/span&gt;
    &lt;span class="p"&gt;],&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_save10_discount&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;subtotal&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;expected_discount&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="nf"&gt;calculate_discount&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;subtotal&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;expected_discount&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The important case is exactly $100.00. It catches the difference between &lt;code&gt;&amp;gt;&lt;/code&gt; and &lt;code&gt;&amp;gt;=&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;You can ask an AI agent to add more cases, but first make it explain which acceptance rule each case protects. If it cannot map a test to a requirement, the test may be noise.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical workflow for AI-assisted QA
&lt;/h2&gt;

&lt;p&gt;I use a five-step mental model for reviewing generated tests.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Write the expected behavior first
&lt;/h3&gt;

&lt;p&gt;Keep acceptance criteria separate from implementation details. Describe inputs, outputs, boundaries, permissions, and failure behavior.&lt;/p&gt;

&lt;p&gt;A useful prompt is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Do not write tests yet. First list ambiguities in this requirement. Ask which decisions need a product or QA answer. Do not invent expected behavior.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This is often more valuable than immediately asking for test code.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Generate tests from the contract
&lt;/h3&gt;

&lt;p&gt;Once the rules are clear, ask the agent for:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Happy-path examples.&lt;/li&gt;
&lt;li&gt;Boundary values immediately below, at, and above thresholds.&lt;/li&gt;
&lt;li&gt;Invalid and missing inputs.&lt;/li&gt;
&lt;li&gt;Permission and role combinations.&lt;/li&gt;
&lt;li&gt;State transitions and retry behavior.&lt;/li&gt;
&lt;li&gt;Failure cases that matter to real users.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Ask it to reference the exact acceptance criterion for every test.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Challenge the tests
&lt;/h3&gt;

&lt;p&gt;A green test suite can still be weak. Try mutation testing: deliberately change a condition, remove a validation, or reverse a comparison. A useful test should fail when the behavior it protects is broken.&lt;/p&gt;

&lt;p&gt;For the discount example, changing &lt;code&gt;subtotal &amp;gt; 100&lt;/code&gt; to &lt;code&gt;subtotal &amp;gt;= 100&lt;/code&gt; should make the $100.00 test fail.&lt;/p&gt;

&lt;p&gt;Also check for tests that only repeat the implementation's assumptions. A test that copies the same mistaken condition from the code is not independent evidence.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Keep human judgment where the expected result is subjective
&lt;/h3&gt;

&lt;p&gt;Not every requirement has a deterministic answer. Accessibility, usability, relevance, tone, and the quality of an AI-generated response may need human evaluation.&lt;/p&gt;

&lt;p&gt;An LLM-as-a-judge can help with these cases, but only when its rubric is explicit and checked against human-labelled examples. A score from another model is not ground truth.&lt;/p&gt;

&lt;p&gt;For a practical discussion of this approach, see &lt;a href="https://dev.to/nikolay_chernev_a67479931/llm-as-a-judge-building-an-ai-grader-you-can-actually-trust-3eao"&gt;LLM-as-a-judge: building an AI grader you can actually trust&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Measure evidence, not test volume
&lt;/h3&gt;

&lt;p&gt;Avoid treating the number of generated tests or line coverage as proof of quality. Track a few signals that tell you whether the suite protects users:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Requirements with at least one meaningful test.&lt;/li&gt;
&lt;li&gt;Important mutations that the suite detects.&lt;/li&gt;
&lt;li&gt;Flaky-test rate.&lt;/li&gt;
&lt;li&gt;Defects escaping to production.&lt;/li&gt;
&lt;li&gt;Time needed to diagnose a failed test.&lt;/li&gt;
&lt;li&gt;Cases where a human reviewer rejects an AI-generated expected result.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These measures are imperfect, but they are closer to product risk than counting how many tests an agent created.&lt;/p&gt;

&lt;h2&gt;
  
  
  What this changes for QA engineers and developers
&lt;/h2&gt;

&lt;p&gt;AI can reduce the time spent writing repetitive test code. That does not remove the need to understand users, identify risk, challenge assumptions, or decide what counts as correct.&lt;/p&gt;

&lt;p&gt;The valuable work moves toward:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Turning vague requirements into testable contracts.&lt;/li&gt;
&lt;li&gt;Finding missing states and edge cases.&lt;/li&gt;
&lt;li&gt;Choosing realistic test data.&lt;/li&gt;
&lt;li&gt;Evaluating generated tests independently.&lt;/li&gt;
&lt;li&gt;Testing workflows that do not have one obvious expected output.&lt;/li&gt;
&lt;li&gt;Explaining why a release is safe enough to ship.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Developers need these skills too. A developer who can generate code and tests quickly but cannot explain the expected behavior is still relying on luck.&lt;/p&gt;

&lt;p&gt;The point is not to keep humans involved in every keystroke. It is to keep a clear owner for the quality decision.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;When an AI agent writes and passes the tests, who owns the expected result on your team — the developer, QA, product, or nobody?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>testing</category>
      <category>qa</category>
      <category>programming</category>
    </item>
    <item>
      <title>AI Isn't Killing Junior Developers. It's Breaking the Learning Path.</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Fri, 06 Nov 2026 13:22:55 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/ai-isnt-killing-junior-developers-its-breaking-the-learning-path-3lak</link>
      <guid>https://dev.to/oleksoleks07/ai-isnt-killing-junior-developers-its-breaking-the-learning-path-3lak</guid>
      <description>&lt;p&gt;AI can generate a CRUD endpoint, write a test, fix a lint error, and explain a stack trace in minutes.&lt;/p&gt;

&lt;p&gt;Those tasks were never the whole job. But they were how many developers learned the job.&lt;/p&gt;

&lt;p&gt;That is the uncomfortable question behind the “Will AI replace junior developers?” debate: &lt;strong&gt;what happens when automation takes over the beginner tasks before teams have redesigned how beginners gain experience?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The answer is not that every junior role disappears. The evidence is more complicated. Hiring demand is changing, the work is shifting toward verification and coordination, and the traditional learning ladder is under pressure.&lt;/p&gt;

&lt;h2&gt;
  
  
  The signals are real — but they do not all say the same thing
&lt;/h2&gt;

&lt;p&gt;A few recent findings are worth separating:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Hiring is changing, not simply stopping.&lt;/strong&gt; In its 29 October 2026 report, &lt;a href="https://www.randstad.com/press/2026/randstad-tech-talent-report-2026/" rel="noopener noreferrer"&gt;Randstad&lt;/a&gt; said 86% of surveyed employers planned to grow technology headcount. It also reported that entry-level tech job postings requiring AI skills had increased fivefold since 2025. That is a change in the skills employers ask for — not proof that total entry-level hiring has increased fivefold.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Developers are losing some of the practice that builds judgment.&lt;/strong&gt; &lt;a href="https://www.adaptavist.com/blog/what-ai-means-for-the-future-of-software-engineering" rel="noopener noreferrer"&gt;Adaptavist's November 2026 research&lt;/a&gt; found that 63% of developers said AI had reduced their hands-on coding, while 43% said they had fewer opportunities to upskill. The report also found that 70% worry junior developers are becoming too reliant on automation.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The entry-level squeeze is visible in some markets.&lt;/strong&gt; In Spain, figures from the DigitalES 2026 employment report, reported by &lt;a href="https://www.servimedia.es/noticias/ia-reduce-33-ofertas-para-programadores-junior-eleva-13-perfiles-senior/1412917004" rel="noopener noreferrer"&gt;Servimedia&lt;/a&gt;, showed junior programmer vacancies down 33% and senior vacancies up 13% over the period studied. This is a market signal, not proof that AI alone caused the change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Quality work is becoming more important.&lt;/strong&gt; TestMu AI's &lt;a href="https://www.testmuai.com/research/state-of-ai-in-quality-engineering/" rel="noopener noreferrer"&gt;State of AI in Quality Engineering 2026&lt;/a&gt; reported that 81% of teams had merged AI-written code or tests they did not fully understand, 44% saw more escaped defects as AI-generated code grew, and 37% of teams building AI agents had no systematic way to evaluate them. This was a survey of the TestMu AI community, so treat it as a useful industry signal rather than a universal measurement.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These findings point in different directions. Employers still expect to need technical talent, but they increasingly want people who can use AI, check its work, understand the system, and take responsibility for outcomes.&lt;/p&gt;

&lt;h2&gt;
  
  
  The first rung of the career ladder is the problem
&lt;/h2&gt;

&lt;p&gt;A junior developer traditionally learned through a sequence of small, imperfect tasks:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Change a form or API endpoint.&lt;/li&gt;
&lt;li&gt;Break something and investigate why.&lt;/li&gt;
&lt;li&gt;Add a test for the failure.&lt;/li&gt;
&lt;li&gt;Get feedback in code review.&lt;/li&gt;
&lt;li&gt;See the change behave in production.&lt;/li&gt;
&lt;li&gt;Gradually take on work with more risk.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;AI can complete several of those steps quickly. That is useful for delivery, but it can also remove the repetition through which a beginner learns debugging, edge cases, data flow, and the consequences of a design decision.&lt;/p&gt;

&lt;p&gt;If a junior asks an agent to build a feature, accepts the diff, and moves on, they may finish the ticket without developing the ability to diagnose the next failure.&lt;/p&gt;

&lt;p&gt;The risk is not that AI writes code. The risk is &lt;strong&gt;mistaking a completed task for acquired competence&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  QA is not disappearing — the work is moving
&lt;/h2&gt;

&lt;p&gt;The same distinction matters for QA.&lt;/p&gt;

&lt;p&gt;Repetitive execution of stable test cases is increasingly automatable. But someone still needs to decide:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which user risks matter most?&lt;/li&gt;
&lt;li&gt;What should happen when the happy path fails?&lt;/li&gt;
&lt;li&gt;Is the test checking the requirement or merely repeating the implementation's assumption?&lt;/li&gt;
&lt;li&gt;Can the AI-generated test detect a real regression?&lt;/li&gt;
&lt;li&gt;What happens with unusual data, slow networks, permissions, or malicious input?&lt;/li&gt;
&lt;li&gt;How do we evaluate an AI agent after its model, prompt, or tools change?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That is quality engineering, not just clicking through a checklist.&lt;/p&gt;

&lt;p&gt;The TestMu survey is a reminder that generating code and generating tests do not automatically produce confidence. A team needs independent checks, useful test data, exploratory thinking, and evidence that the system behaves correctly.&lt;/p&gt;

&lt;p&gt;For QA engineers, useful next skills include API testing, SQL, browser automation, CI pipelines, observability, risk-based testing, and evaluation of AI systems. Manual testing still matters when it means exploring uncertainty and understanding real user behavior — not simply repeating steps that a script can execute.&lt;/p&gt;

&lt;h2&gt;
  
  
  A more useful learning path for developers
&lt;/h2&gt;

&lt;p&gt;You do not need to reject AI to build strong foundations. You need to use it in a way that keeps you responsible for understanding the result.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Build one small thing without delegating the fundamentals
&lt;/h3&gt;

&lt;p&gt;Create a small application with an API, a database, authentication, and a basic UI. You can use documentation and search, but write enough of it yourself to understand the request flow, data model, and failure cases.&lt;/p&gt;

&lt;p&gt;You should be able to explain what happens when a request is duplicated, a token expires, a database call times out, or a user has the wrong permissions.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Use AI as a reviewer and pair, not as an answer machine
&lt;/h3&gt;

&lt;p&gt;For the next feature, ask an AI assistant to:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;propose a plan before changing files;&lt;/li&gt;
&lt;li&gt;identify assumptions and likely edge cases;&lt;/li&gt;
&lt;li&gt;suggest tests before implementation;&lt;/li&gt;
&lt;li&gt;explain the diff in plain language.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Then inspect the actual code. Run the tests. Add a case the agent did not consider. If you cannot explain why a change is safe, do not treat the agent's confidence as evidence.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Learn to investigate failures
&lt;/h3&gt;

&lt;p&gt;Take a bug and follow it from symptom to root cause. Read logs, reproduce it, reduce it to a small example, and verify the fix.&lt;/p&gt;

&lt;p&gt;This is where fundamentals pay off. AI can suggest hypotheses, but you need to know which evidence would confirm or reject them.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Practice system-level thinking
&lt;/h3&gt;

&lt;p&gt;Learn how APIs, databases, queues, permissions, deployments, monitoring, and rollback fit together. A feature that works in a local demo can still fail under load, expose data, or corrupt state.&lt;/p&gt;

&lt;p&gt;The more code generation becomes cheap, the more valuable it is to understand the system into which that code is being introduced.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Show evidence of judgment
&lt;/h3&gt;

&lt;p&gt;A portfolio made of polished AI-generated demos is weak evidence by itself. Show the decisions behind the work:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;a bug you reproduced and fixed;&lt;/li&gt;
&lt;li&gt;tests for edge cases;&lt;/li&gt;
&lt;li&gt;a pull request where you responded to review;&lt;/li&gt;
&lt;li&gt;a trade-off you considered and rejected;&lt;/li&gt;
&lt;li&gt;a short postmortem explaining what failed and what you changed.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Open-source contributions, issue discussions, and reviewed pull requests can show how you think — not just that you can produce a finished screen.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical 90-day plan
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Period&lt;/th&gt;
&lt;th&gt;Focus&lt;/th&gt;
&lt;th&gt;Evidence to keep&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Days 1–30&lt;/td&gt;
&lt;td&gt;Build a small app and understand its API, data model, tests, and failure modes&lt;/td&gt;
&lt;td&gt;A working repo and a short architecture explanation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Days 31–60&lt;/td&gt;
&lt;td&gt;Use one AI coding assistant on bounded tasks; review every diff and add tests&lt;/td&gt;
&lt;td&gt;A log of accepted/rejected suggestions and test results&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Days 61–90&lt;/td&gt;
&lt;td&gt;Fix an issue in your own project or contribute to an existing one; add CI and document a real trade-off&lt;/td&gt;
&lt;td&gt;A reviewed PR, regression test, or concise postmortem&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;For QA learners, make the project testable: include API checks, boundary cases, a browser flow, and at least one test that tries to break the expected behavior. For developers, make the same project observable and recoverable: logs, error handling, and a documented rollback path.&lt;/p&gt;

&lt;h2&gt;
  
  
  What engineering teams should change
&lt;/h2&gt;

&lt;p&gt;This is not only a junior developer's responsibility.&lt;/p&gt;

&lt;p&gt;If companies automate beginner tasks, they need to create new ways for beginners to practice the underlying skills. That can mean bounded tickets, pairing sessions, debugging exercises, review rotations, production shadowing, and time to explain why a change is safe.&lt;/p&gt;

&lt;p&gt;Teams should also stop treating AI usage as a performance metric by itself. Measure accepted changes, escaped defects, recovery time, review load, and whether engineers can explain the systems they maintain.&lt;/p&gt;

&lt;p&gt;Senior engineers will still need to mentor. QA engineers will still need to challenge assumptions. Junior engineers will still need room to make small mistakes before they are trusted with large ones.&lt;/p&gt;

&lt;h2&gt;
  
  
  The job is changing. The learning still has to happen.
&lt;/h2&gt;

&lt;p&gt;AI may remove some of the tasks through which people used to enter software development. It does not remove the need for people who understand requirements, systems, risk, and consequences.&lt;/p&gt;

&lt;p&gt;The career path will have to change with the tools. The worst outcome would be to automate the apprenticeship, hire only people who already have experience, and then wonder where the next generation of experienced engineers will come from.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;If you are a junior developer or QA engineer, which task helped you learn the most — and is AI taking that task away, or helping you learn it faster?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>career</category>
      <category>programming</category>
      <category>beginners</category>
    </item>
    <item>
      <title>Your AI Coding Agent Has a Supply Chain. Are You Auditing It?</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Wed, 04 Nov 2026 16:39:09 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/your-ai-coding-agent-has-a-supply-chain-are-you-auditing-it-19gm</link>
      <guid>https://dev.to/oleksoleks07/your-ai-coding-agent-has-a-supply-chain-are-you-auditing-it-19gm</guid>
      <description>&lt;h1&gt;
  
  
  Your AI Coding Agent Has a Supply Chain. Are You Auditing It?
&lt;/h1&gt;

&lt;p&gt;A coding agent can follow every approval prompt you give it and still run malicious code.&lt;/p&gt;

&lt;p&gt;That is the uncomfortable part of the new AI developer-tool supply chain: the model is not the only thing with access to your machine. Plugins, skills, MCP servers, editor extensions, hooks, and helper packages can execute with the permissions of the developer who installed them.&lt;/p&gt;

&lt;p&gt;CERT-EU recently demonstrated how seemingly legitimate third-party agent packages could be modified to collect credentials in the background. The lesson is bigger than “be careful what you install.” We need to treat agent extensions like production dependencies.&lt;/p&gt;

&lt;p&gt;Here is a practical way to do that without turning every experiment into a security review project.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Inventory the whole agent stack
&lt;/h2&gt;

&lt;p&gt;Most teams already track npm, Python, and container dependencies. Add the components that extend your coding agent:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;MCP servers and their package versions&lt;/li&gt;
&lt;li&gt;Agent skills and prompt packs&lt;/li&gt;
&lt;li&gt;Editor extensions&lt;/li&gt;
&lt;li&gt;Lifecycle hooks and shell scripts&lt;/li&gt;
&lt;li&gt;Local tools the agent can invoke&lt;/li&gt;
&lt;li&gt;Remote services the agent can authenticate to&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Keep the inventory in the repository or an internal document. Record the source, version or commit, maintainer, permissions, and why the team needs it.&lt;/p&gt;

&lt;p&gt;If you cannot answer “what code runs when this agent starts?”, your inventory is incomplete.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Review capabilities, not marketing descriptions
&lt;/h2&gt;

&lt;p&gt;A tool described as “GitHub integration” might read issues, create branches, push commits, open pull requests, or access repository secrets. Those are very different risk levels.&lt;/p&gt;

&lt;p&gt;For every extension or MCP server, ask:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Can it read files outside the current project?&lt;/li&gt;
&lt;li&gt;Can it execute shell commands or start processes?&lt;/li&gt;
&lt;li&gt;Can it access environment variables, tokens, or SSH credentials?&lt;/li&gt;
&lt;li&gt;Can it make outbound network requests?&lt;/li&gt;
&lt;li&gt;Can it modify files or publish changes without approval?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Write down the actual capabilities. Do not infer them from the tool's name or marketplace description.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Apply least privilege at the process boundary
&lt;/h2&gt;

&lt;p&gt;Agent approval prompts are useful, but they are not a complete sandbox for code running alongside the agent.&lt;/p&gt;

&lt;p&gt;Use separate boundaries:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Run experiments in a disposable container or VM.&lt;/li&gt;
&lt;li&gt;Mount only the repository and directories the task needs.&lt;/li&gt;
&lt;li&gt;Keep production credentials out of local agent environments.&lt;/li&gt;
&lt;li&gt;Use short-lived, narrowly scoped tokens.&lt;/li&gt;
&lt;li&gt;Restrict outbound network access where practical.&lt;/li&gt;
&lt;li&gt;Require human approval for external side effects.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A useful default: an agent working on a feature branch should not inherit credentials that can deploy production.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Pin, verify, and update deliberately
&lt;/h2&gt;

&lt;p&gt;For every component, prefer a specific version or immutable commit over a floating branch or an unpinned “latest” install.&lt;/p&gt;

&lt;p&gt;But do not confuse pinning with verification. Check that the code actually installed matches the version or commit you reviewed. A pinned reference is only useful if the installation process verifies what landed on disk.&lt;/p&gt;

&lt;p&gt;For high-impact tools, keep a small record:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Field&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Component&lt;/td&gt;
&lt;td&gt;MCP filesystem server&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Source&lt;/td&gt;
&lt;td&gt;Official repository&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Version&lt;/td&gt;
&lt;td&gt;Exact release / commit&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Permissions&lt;/td&gt;
&lt;td&gt;Read/write to one workspace&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;Disabled unless required&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Owner&lt;/td&gt;
&lt;td&gt;Team or maintainer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Review date&lt;/td&gt;
&lt;td&gt;Date last checked&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  5. Make security checks part of onboarding
&lt;/h2&gt;

&lt;p&gt;A lightweight checklist is better than a long policy nobody follows.&lt;/p&gt;

&lt;p&gt;Before enabling a new agent tool:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;[ ] Confirm the source and maintainer.&lt;/li&gt;
&lt;li&gt;[ ] Inspect the code or package contents when feasible.&lt;/li&gt;
&lt;li&gt;[ ] Check requested filesystem, shell, and network access.&lt;/li&gt;
&lt;li&gt;[ ] Pin an exact version or commit.&lt;/li&gt;
&lt;li&gt;[ ] Test in an isolated environment first.&lt;/li&gt;
&lt;li&gt;[ ] Use dummy credentials during evaluation.&lt;/li&gt;
&lt;li&gt;[ ] Document the owner and reason for using it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Revisit the list when permissions change or a component updates.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Treat agent tools like dependencies, not accessories
&lt;/h2&gt;

&lt;p&gt;The key shift is conceptual: an MCP server or agent skill is not just a prompt enhancement. It is part of the software that executes in your development environment.&lt;/p&gt;

&lt;p&gt;That means it deserves the same questions we ask about a new dependency: Who maintains it? What can it access? How is it updated? What happens if it is compromised?&lt;/p&gt;

&lt;p&gt;You do not need to ban third-party tools. You need to make their trust boundary visible.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical starting point
&lt;/h2&gt;

&lt;p&gt;Pick the five agent extensions or MCP servers your team uses most. For each one, write down its source, exact version, permissions, network access, and owner. Then remove permissions that are not required for its actual job.&lt;/p&gt;

&lt;p&gt;That one-hour exercise will usually reveal more than another generic “AI security” policy.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How are you managing the supply chain around your coding agents today?&lt;/strong&gt; Do you have an inventory and permission review, or are tools still being added one marketplace install at a time?&lt;/p&gt;




&lt;p&gt;Further reading: &lt;a href="https://www.cert.europa.eu/blog/beyond-the-model-backdoors-in-ai-agent-harnesses" rel="noopener noreferrer"&gt;CERT-EU — Beyond the model: backdoors in AI agent harnesses&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>devtools</category>
      <category>programming</category>
    </item>
    <item>
      <title>AI Coding Is Scaling Faster Than Your CI Pipeline. Here’s What I’d Change</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Mon, 02 Nov 2026 13:12:08 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/ai-coding-is-scaling-faster-than-your-ci-pipeline-heres-what-id-change-5j6</link>
      <guid>https://dev.to/oleksoleks07/ai-coding-is-scaling-faster-than-your-ci-pipeline-heres-what-id-change-5j6</guid>
      <description>&lt;p&gt;AI coding agents are changing the unit of work in software development.&lt;/p&gt;

&lt;p&gt;A developer used to write a change, run tests, open a pull request, and repeat. Now an agent can start a pull request, modify multiple files, run commands, and hand the result back for review.&lt;/p&gt;

&lt;p&gt;That changes something easy to overlook: &lt;strong&gt;your CI pipeline becomes part of the AI interface.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If agents can produce work faster than your checks can evaluate it, the bottleneck moves from coding to feedback.&lt;/p&gt;

&lt;p&gt;GitHub’s 2026 Octoverse report shows how quickly this is happening. In September 2026, more than 40% of pull requests on GitHub started with an agent, up from 17% in March. GitHub also reported 34.3 billion commits and 45.4 billion GitHub Actions jobs over the year ending September 30. &lt;a href="https://github.blog/news-insights/octoverse/octoverse-commits-pushes-reach-new-highs-in-2026-as-developers-build-with-agents/" rel="noopener noreferrer"&gt;GitHub Octoverse 2026&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;So what should developers change?&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Make fast checks the first feedback loop
&lt;/h2&gt;

&lt;p&gt;An agent does not need your entire CI system after every small edit.&lt;/p&gt;

&lt;p&gt;Give it a cheap local loop first:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;edit
  ↓
format
  ↓
lint
  ↓
typecheck
  ↓
focused tests
  ↓
full CI
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The goal is simple: catch obvious failures in seconds, not minutes.&lt;/p&gt;

&lt;p&gt;For example, if a TypeScript agent changes one component, running the entire end-to-end suite immediately may waste both compute and agent time. A targeted typecheck and component test can give much faster feedback.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Treat CI results as agent-readable data
&lt;/h2&gt;

&lt;p&gt;Humans can understand a red build from a dashboard. Agents need structured feedback.&lt;/p&gt;

&lt;p&gt;Instead of returning a wall of logs, expose the useful information clearly:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;CHECK: typecheck
STATUS: failed
FILE: src/components/Search.tsx
LINE: 42
ERROR: Property 'query' does not exist on type 'SearchProps'
NEXT_STEP: inspect SearchProps and update the caller or interface
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This makes the next agent action much more deterministic.&lt;/p&gt;

&lt;p&gt;The principle is similar to designing an API: &lt;strong&gt;good error messages are part of the interface.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Separate cheap checks from expensive checks
&lt;/h2&gt;

&lt;p&gt;Not every check deserves the same place in the pipeline.&lt;/p&gt;

&lt;p&gt;I would divide them into three groups.&lt;/p&gt;

&lt;h3&gt;
  
  
  Fast
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;formatting&lt;/li&gt;
&lt;li&gt;linting&lt;/li&gt;
&lt;li&gt;type checking&lt;/li&gt;
&lt;li&gt;focused unit tests&lt;/li&gt;
&lt;li&gt;static analysis&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Medium
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;broader unit/integration tests&lt;/li&gt;
&lt;li&gt;build verification&lt;/li&gt;
&lt;li&gt;API contract tests&lt;/li&gt;
&lt;li&gt;browser tests for affected areas&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Expensive
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;full end-to-end suites&lt;/li&gt;
&lt;li&gt;large integration environments&lt;/li&gt;
&lt;li&gt;performance tests&lt;/li&gt;
&lt;li&gt;deployment previews&lt;/li&gt;
&lt;li&gt;security scans that require substantial infrastructure&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Agents should get the first group as early as possible. The expensive checks should protect the merge or deployment boundary.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Give agents a way to know when to stop
&lt;/h2&gt;

&lt;p&gt;One of the less obvious problems with autonomous coding is that an agent can keep acting when the correct action is to stop.&lt;/p&gt;

&lt;p&gt;A 2026 study of 20,574 real-world coding-agent sessions found recurring misalignment problems involving project rules, constraints, implementation, execution, and reporting. The researchers found that 91.49% of visible resolutions still required explicit user correction. &lt;a href="https://arxiv.org/abs/2605.29442" rel="noopener noreferrer"&gt;The study&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;That suggests a useful CI rule:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A failed check should not automatically mean “try another fix.”&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Sometimes the right result is:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;TEST FAILED

Reason: behavior is ambiguous.

Required action: ask the developer for clarification.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is especially important when a change affects authentication, payments, data deletion, permissions, or production infrastructure.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Measure feedback latency, not just build time
&lt;/h2&gt;

&lt;p&gt;Teams often measure how long CI takes.&lt;/p&gt;

&lt;p&gt;With coding agents, I would add another metric:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;How long does it take from an agent making a change to receiving a useful signal about that change?&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Call it feedback latency.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Workflow&lt;/th&gt;
&lt;th&gt;Feedback latency&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Format + lint&lt;/td&gt;
&lt;td&gt;5–15 sec&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Typecheck&lt;/td&gt;
&lt;td&gt;10–30 sec&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Focused tests&lt;/td&gt;
&lt;td&gt;20–60 sec&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Full test suite&lt;/td&gt;
&lt;td&gt;5–15 min&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Full CI + preview&lt;/td&gt;
&lt;td&gt;10–30 min&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The exact numbers depend on the project. The important part is the shape of the loop.&lt;/p&gt;

&lt;p&gt;If an agent needs 15 minutes to discover that it introduced a simple type error, you are paying for 15 minutes of unnecessary waiting before the next decision.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Use stacked changes instead of giant agent PRs
&lt;/h2&gt;

&lt;p&gt;Agents are particularly good at making multi-file changes. GitHub reports that about 87% of agent-involved pull requests changed multiple files, compared with 79% of pull requests without detected agent involvement.&lt;/p&gt;

&lt;p&gt;That makes review boundaries more important.&lt;/p&gt;

&lt;p&gt;Instead of asking an agent to implement an entire feature in one enormous PR, split the work when possible:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;PR 1 → data model
PR 2 → API
PR 3 → UI
PR 4 → tests
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Each step creates a smaller unit of feedback.&lt;/p&gt;

&lt;p&gt;The objective is not to create more bureaucracy. It is to make mistakes cheaper to detect.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Build CI for the developer you have today
&lt;/h2&gt;

&lt;p&gt;There is a tempting mistake here: redesigning the entire engineering platform around hypothetical autonomous agents.&lt;/p&gt;

&lt;p&gt;I would not do that.&lt;/p&gt;

&lt;p&gt;Start with one repository and ask:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which checks give agents useful feedback fastest?&lt;/li&gt;
&lt;li&gt;Which failures are too noisy to act on automatically?&lt;/li&gt;
&lt;li&gt;Which tests are safe to run without human approval?&lt;/li&gt;
&lt;li&gt;Which actions should always require a person?&lt;/li&gt;
&lt;li&gt;Can the important result of each check be represented as structured text?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Then improve the loop incrementally.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bigger shift
&lt;/h2&gt;

&lt;p&gt;The most interesting consequence of AI coding agents may not be that they write more code.&lt;/p&gt;

&lt;p&gt;It is that &lt;strong&gt;feedback becomes a development resource&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;When one developer can coordinate several agent-driven changes, a slow or opaque CI system wastes more than compute. It wastes the developer's attention and the agent's execution time.&lt;/p&gt;

&lt;p&gt;That means the next generation of developer tooling should optimize not only for faster code generation, but for faster, clearer, more trustworthy feedback.&lt;/p&gt;

&lt;p&gt;The best agent is not the one that changes the most files.&lt;/p&gt;

&lt;p&gt;It is the one that can quickly learn whether its last change was a good idea.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;If you are already using coding agents, what is the biggest bottleneck in your feedback loop: tests, CI time, review, or something else?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>devtools</category>
      <category>programming</category>
      <category>automation</category>
    </item>
    <item>
      <title>AI Agents Can Write Code. Should You Let Them Deploy It?</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Fri, 30 Oct 2026 13:04:30 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/ai-agents-can-write-code-should-you-let-them-deploy-it-4ld7</link>
      <guid>https://dev.to/oleksoleks07/ai-agents-can-write-code-should-you-let-them-deploy-it-4ld7</guid>
      <description>&lt;p&gt;AI coding agents are becoming normal developer tools. The interesting question is no longer whether they can write code.&lt;/p&gt;

&lt;p&gt;It is &lt;strong&gt;where you should let them act without a human&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Stack Overflow’s 2026 Developer Survey found that 66% of respondents use AI coding assistants or agents, and 73% of those users use them daily. But the same survey shows a much more cautious pattern when the action becomes operational: developers delegate writing code and debugging far more often than deploying software.&lt;/p&gt;

&lt;p&gt;That gap is useful.&lt;/p&gt;

&lt;p&gt;It suggests a practical rule for AI-assisted development:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Automate the work first. Keep the consequences human-controlled.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Not every task has the same risk
&lt;/h2&gt;

&lt;p&gt;Imagine an AI agent working on a small web application. You could let it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;explain an unfamiliar function&lt;/li&gt;
&lt;li&gt;generate a unit test&lt;/li&gt;
&lt;li&gt;refactor repetitive code&lt;/li&gt;
&lt;li&gt;update documentation&lt;/li&gt;
&lt;li&gt;open a pull request&lt;/li&gt;
&lt;li&gt;merge the pull request&lt;/li&gt;
&lt;li&gt;deploy directly to production&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Those are not six versions of the same permission.&lt;/p&gt;

&lt;p&gt;The first tasks are relatively easy to verify and reverse. The last one can create consequences outside the codebase.&lt;/p&gt;

&lt;p&gt;That means an agent should not receive one giant permission called &lt;code&gt;do_the_job&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  A simple permission ladder
&lt;/h2&gt;

&lt;p&gt;I like thinking about agent permissions as a ladder:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Level 1 — Read
  Inspect files, logs, docs, and configuration.

Level 2 — Suggest
  Generate code, tests, plans, and patches.

Level 3 — Change
  Modify files and run local checks.

Level 4 — Propose
  Create a pull request or change request for review.

Level 5 — Execute
  Merge, publish, deploy, or change production systems.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Most everyday coding-agent work can happen safely in Levels 1–4.&lt;/p&gt;

&lt;p&gt;Level 5 deserves a different standard.&lt;/p&gt;

&lt;h2&gt;
  
  
  Let the agent prove its work
&lt;/h2&gt;

&lt;p&gt;A useful agent workflow is not:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Task → Agent → Production
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It is closer to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Task
  ↓
Inspect
  ↓
Plan
  ↓
Implement
  ↓
Test
  ↓
Show evidence
  ↓
Human review
  ↓
Deploy
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The important addition is &lt;strong&gt;show evidence&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Ask the agent to report:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Which files changed.&lt;/li&gt;
&lt;li&gt;Which tests it added or modified.&lt;/li&gt;
&lt;li&gt;Which commands it actually ran.&lt;/li&gt;
&lt;li&gt;The test results.&lt;/li&gt;
&lt;li&gt;Any assumptions it made.&lt;/li&gt;
&lt;li&gt;Anything it could not verify.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This makes the agent's output easier to audit instead of treating its explanation as proof.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why deployment is different
&lt;/h2&gt;

&lt;p&gt;A failed unit test is usually a clear signal.&lt;/p&gt;

&lt;p&gt;A bad production deployment can be much messier:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;users can lose access&lt;/li&gt;
&lt;li&gt;data can be corrupted&lt;/li&gt;
&lt;li&gt;secrets can be exposed&lt;/li&gt;
&lt;li&gt;infrastructure costs can increase&lt;/li&gt;
&lt;li&gt;a dependency can break an unrelated service&lt;/li&gt;
&lt;li&gt;a seemingly harmless migration can be difficult to reverse&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The agent may be perfectly capable of executing the deployment command and still be the wrong system to decide &lt;strong&gt;whether this particular deployment should happen now&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That distinction matters.&lt;/p&gt;

&lt;p&gt;Technical ability and decision authority are not the same thing.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 10-minute experiment
&lt;/h2&gt;

&lt;p&gt;If you are introducing coding agents into a project, try this before giving them production access.&lt;/p&gt;

&lt;p&gt;Pick one small feature and ask the agent to complete it with these constraints:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;You may inspect the repository and modify source files.

You must:
- explain the current implementation first
- make the smallest reasonable change
- add or update tests
- run the relevant checks
- report the exact commands and results
- list assumptions and remaining risks

Do not deploy, merge, or modify production systems.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then review the result like a normal pull request.&lt;/p&gt;

&lt;p&gt;You are not trying to prove that the agent is perfect. You are measuring how much of the development loop it can handle &lt;strong&gt;without increasing your review burden&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That last part is important.&lt;/p&gt;

&lt;p&gt;If an agent saves 30 minutes of typing but creates 45 minutes of verification work, the workflow is not necessarily faster.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the 2026 data suggests
&lt;/h2&gt;

&lt;p&gt;The Stack Overflow survey gives a useful picture of where developers are comfortable delegating work.&lt;/p&gt;

&lt;p&gt;Among respondents who use AI agents, writing or generating code was delegated by 72.9%, debugging by 62.2%, and writing or maintaining tests by 50.6%.&lt;/p&gt;

&lt;p&gt;Deployment was only 9.8%.&lt;/p&gt;

&lt;p&gt;That does not prove that deployment automation is bad. It shows something more interesting: &lt;strong&gt;developers are already drawing a boundary between generating changes and causing external effects&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That boundary is worth designing intentionally.&lt;/p&gt;

&lt;h2&gt;
  
  
  My default setup
&lt;/h2&gt;

&lt;p&gt;For a small web project, my starting point would be:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agent can:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;read the repository&lt;/li&gt;
&lt;li&gt;search documentation&lt;/li&gt;
&lt;li&gt;edit code&lt;/li&gt;
&lt;li&gt;run tests and linters&lt;/li&gt;
&lt;li&gt;inspect build output&lt;/li&gt;
&lt;li&gt;prepare commits or pull requests&lt;/li&gt;
&lt;li&gt;explain its changes&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Agent must ask for approval before:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;merging to the main branch&lt;/li&gt;
&lt;li&gt;changing production configuration&lt;/li&gt;
&lt;li&gt;modifying databases&lt;/li&gt;
&lt;li&gt;rotating secrets&lt;/li&gt;
&lt;li&gt;deploying production&lt;/li&gt;
&lt;li&gt;spending money through external services&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;As confidence grows, individual permissions can be expanded.&lt;/p&gt;

&lt;p&gt;That is much safer than starting with full access and trying to discover the dangerous edge cases afterward.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bigger idea
&lt;/h2&gt;

&lt;p&gt;The next step in AI-assisted development is not simply giving agents more autonomy.&lt;/p&gt;

&lt;p&gt;It is designing &lt;strong&gt;better boundaries around autonomy&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The best workflow may be the one where the agent is extremely autonomous inside a well-defined sandbox, while a human remains responsible for the few actions that are expensive, irreversible, or difficult to verify.&lt;/p&gt;

&lt;p&gt;AI agents are getting very good at producing changes.&lt;/p&gt;

&lt;p&gt;Our job is to get better at deciding &lt;strong&gt;which changes they are allowed to make on their own&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where would you draw the line: what is the first action you would never let a coding agent perform without human approval?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Sources:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Stack Overflow Developer Survey 2026 — AI usage: &lt;a href="https://survey.stackoverflow.co/2026/ai" rel="noopener noreferrer"&gt;https://survey.stackoverflow.co/2026/ai&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Stack Overflow Developer Survey 2026 — tasks delegated to AI agents: &lt;a href="https://survey.stackoverflow.co/2026/knowledge/data/know-agent-delegate" rel="noopener noreferrer"&gt;https://survey.stackoverflow.co/2026/knowledge/data/know-agent-delegate&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>devtools</category>
      <category>automation</category>
    </item>
    <item>
      <title>AI Coding Agents Are Fast. Your Review Process Needs to Be Faster.</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Wed, 28 Oct 2026 15:07:04 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/ai-coding-agents-are-fast-your-review-process-needs-to-be-faster-31f1</link>
      <guid>https://dev.to/oleksoleks07/ai-coding-agents-are-fast-your-review-process-needs-to-be-faster-31f1</guid>
      <description>&lt;p&gt;AI coding agents are getting good enough that “write the code” is no longer the interesting part.&lt;/p&gt;

&lt;p&gt;The harder problem is &lt;strong&gt;knowing whether the code is correct before you trust it&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That matters because AI-assisted development is no longer a niche workflow. Stack Overflow’s 2026 Developer Survey reports that 66% of respondents use AI coding assistants or agents, and 73% of those users use them daily. At the same time, developers still tend to trust AI more for technical tasks with checkable answers than for ambiguous work.&lt;/p&gt;

&lt;p&gt;So I’ve been thinking about a simple rule for working with coding agents:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Don’t ask an agent only for code. Ask it for evidence.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  What “evidence” means
&lt;/h2&gt;

&lt;p&gt;Suppose you ask an agent:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Add input validation to this form.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A weak workflow ends when the agent says it is done.&lt;/p&gt;

&lt;p&gt;A stronger workflow asks for:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The implementation.&lt;/li&gt;
&lt;li&gt;The tests it added or changed.&lt;/li&gt;
&lt;li&gt;The edge cases it considered.&lt;/li&gt;
&lt;li&gt;The commands it ran.&lt;/li&gt;
&lt;li&gt;The actual test output.&lt;/li&gt;
&lt;li&gt;Any assumptions it made.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That small change turns the agent from a code generator into something closer to a junior engineer who must show their work.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical prompt pattern
&lt;/h2&gt;

&lt;p&gt;For small features, I like a structure like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Implement this feature.

Before changing code:
- inspect the relevant files
- explain the current behavior briefly
- identify likely edge cases

After changing code:
- add or update tests
- run the relevant test suite
- report the exact commands you ran
- report failures honestly
- summarize assumptions and remaining risks

Do not claim a test passed unless you actually ran it.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The last line is particularly important. An agent can produce a convincing explanation without having executed anything.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this works
&lt;/h2&gt;

&lt;p&gt;AI-generated code is easiest to trust when the result is independently checkable.&lt;/p&gt;

&lt;p&gt;For example, these tasks have relatively clear feedback loops:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;unit tests&lt;/li&gt;
&lt;li&gt;type checking&lt;/li&gt;
&lt;li&gt;linting&lt;/li&gt;
&lt;li&gt;build commands&lt;/li&gt;
&lt;li&gt;formatting checks&lt;/li&gt;
&lt;li&gt;browser tests&lt;/li&gt;
&lt;li&gt;API contract tests&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The agent can make a change, run the check, see the result, and iterate.&lt;/p&gt;

&lt;p&gt;The situation is very different when the question is something like:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Is this architecture going to scale for the next three years?”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;There may be no single command that proves the answer.&lt;/p&gt;

&lt;p&gt;That is where human judgment becomes much more important.&lt;/p&gt;

&lt;h2&gt;
  
  
  The review loop I would use
&lt;/h2&gt;

&lt;p&gt;For an AI-assisted feature, a useful loop is:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Plan → Implement → Test → Inspect → Review → Merge&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The key is not to remove the human from the loop. It is to move the human toward the decisions where human judgment has the most value.&lt;/p&gt;

&lt;p&gt;Instead of spending 20 minutes checking whether a missing semicolon broke the build, let automated checks handle that.&lt;/p&gt;

&lt;p&gt;Spend those 20 minutes asking:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Did we solve the right problem?&lt;/li&gt;
&lt;li&gt;Is this change simpler than the alternatives?&lt;/li&gt;
&lt;li&gt;Does the code fit the existing architecture?&lt;/li&gt;
&lt;li&gt;What happens with unexpected input?&lt;/li&gt;
&lt;li&gt;What happens when an external service fails?&lt;/li&gt;
&lt;li&gt;Did the agent introduce a security or privacy problem?&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  One more useful habit: ask for a diff summary
&lt;/h2&gt;

&lt;p&gt;Before reviewing a large AI-generated change, ask the agent to summarize the diff in plain language:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Review your own changes.

Give me:
- files changed
- behavior changed
- tests added/updated
- potential regressions
- security-sensitive changes
- anything you are uncertain about
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is not a replacement for reading the diff. It is a way to decide &lt;strong&gt;where to read the diff first&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bigger shift
&lt;/h2&gt;

&lt;p&gt;The interesting change in agentic coding is not simply that machines can write more code.&lt;/p&gt;

&lt;p&gt;It is that the developer's job increasingly becomes &lt;strong&gt;orchestration and verification&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Current research reflects that shift. Anthropic's 2026 agentic coding report describes software development moving toward orchestrating agents while keeping human judgment and oversight in the loop. JetBrains' 2026 developer survey also reports widespread weekly and daily use of AI coding agents among professional developers.&lt;/p&gt;

&lt;p&gt;That suggests a useful skill for developers to build now:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Learn how to design good verification loops, not just good prompts.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A clever prompt can get you a better first draft. A good verification loop tells you whether that draft deserves to ship.&lt;/p&gt;

&lt;h2&gt;
  
  
  Final thought
&lt;/h2&gt;

&lt;p&gt;AI coding agents can make implementation dramatically cheaper. That makes verification more valuable, not less.&lt;/p&gt;

&lt;p&gt;If an agent can write 500 lines in a few minutes, the scarce resource is no longer typing those 500 lines.&lt;/p&gt;

&lt;p&gt;It is your confidence that they should exist.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is your best technique for verifying code written by AI agents?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>webdev</category>
      <category>productivity</category>
    </item>
    <item>
      <title>I Built a Free Collection of Construction Calculators</title>
      <dc:creator>oleksoleks07</dc:creator>
      <pubDate>Mon, 26 Oct 2026 16:07:28 +0000</pubDate>
      <link>https://dev.to/oleksoleks07/i-built-a-free-collection-of-construction-calculators-22ne</link>
      <guid>https://dev.to/oleksoleks07/i-built-a-free-collection-of-construction-calculators-22ne</guid>
      <description>&lt;p&gt;Construction projects often involve repetitive calculations: estimating concrete volume, calculating areas, measuring materials, or converting units. Even simple mistakes can lead to wasted materials, extra costs, and unnecessary work.&lt;/p&gt;

&lt;p&gt;I wanted to make these calculations easier, so I built &lt;strong&gt;Free Construction Calculators&lt;/strong&gt;, a website with free online tools for everyday construction calculations.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Try it here:&lt;/strong&gt; &lt;a href="https://free-construction-calculators.pages.dev/" rel="noopener noreferrer"&gt;https://free-construction-calculators.pages.dev/&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What can you use it for?
&lt;/h2&gt;

&lt;p&gt;The goal is simple: make common construction calculations accessible directly in your browser.&lt;/p&gt;

&lt;p&gt;Instead of searching for formulas every time or calculating everything manually, you can use online tools to get results quickly.&lt;/p&gt;

&lt;p&gt;The project focuses on making calculators straightforward to use, with a practical approach that doesn't require installing software or creating an account.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why I built it
&lt;/h2&gt;

&lt;p&gt;I like building small, useful web projects that solve real problems.&lt;/p&gt;

&lt;p&gt;Construction calculations are a good example of something that can be made easier with a simple web interface. My goal is to keep expanding the collection and make the tools useful for homeowners, DIY enthusiasts, builders, and anyone working on a construction project.&lt;/p&gt;

&lt;h2&gt;
  
  
  What's next?
&lt;/h2&gt;

&lt;p&gt;I'm continuing to improve the website and explore which calculators would be most useful to add.&lt;/p&gt;

&lt;p&gt;If you work in construction, enjoy DIY projects, or have experience building practical web tools, I'd like to hear your thoughts.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which construction calculator would you find most useful?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Explore the project: &lt;a href="https://free-construction-calculators.pages.dev/" rel="noopener noreferrer"&gt;https://free-construction-calculators.pages.dev/&lt;/a&gt;&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>javascript</category>
      <category>beginners</category>
      <category>showdev</category>
    </item>
  </channel>
</rss>
