<?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: Chris Faraglia </title>
    <description>The latest articles on DEV Community by Chris Faraglia  (@chris-faraglia).</description>
    <link>https://dev.to/chris-faraglia</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%2F4119480%2Fcb61b02e-8b6c-47b1-851d-091bf80b6510.jpg</url>
      <title>DEV Community: Chris Faraglia </title>
      <link>https://dev.to/chris-faraglia</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/chris-faraglia"/>
    <language>en</language>
    <item>
      <title>Why AI-Generated Code Needs Your Existing Regression Tests</title>
      <dc:creator>Chris Faraglia </dc:creator>
      <pubDate>Wed, 28 Oct 2026 14:23:36 +0000</pubDate>
      <link>https://dev.to/chris-faraglia/why-ai-generated-code-needs-your-existing-regression-tests-47g0</link>
      <guid>https://dev.to/chris-faraglia/why-ai-generated-code-needs-your-existing-regression-tests-47g0</guid>
      <description>&lt;p&gt;AI coding assistants can implement new features quickly, but they don't inherently know which existing product behaviors those changes must preserve. For example, a 2026 &lt;a href="https://survey.stackoverflow.co/2026/technology/data/disruption" rel="noopener noreferrer"&gt;Stack Overflow Developer Survey&lt;/a&gt; found that 69% of respondents cited plausible but incorrect code among the AI mistakes that cost them or their teams the most time over the past year.&lt;/p&gt;

&lt;p&gt;The reason for this disconnect is that faster code doesn’t inherently guarantee better quality outputs. As soon as the code reaches a testing checkpoint, AI-related errors become apparent. This leaves software developers to debug and rework the product until it is ready for production.&lt;/p&gt;

&lt;p&gt;What AI tools are missing is context. They often depend on static requirements documents that outline what to build, but lack the customer-specific knowledge required to create production-ready applications. Yet, this context already exists. Test artifacts and execution evidence capture business rules, historical behavior, and edge cases that demonstrate how code is supposed to function in practice. The challenge is that this information often enters the SDLC as a final checkpoint. &lt;br&gt;
Addressing this discrepancy requires bringing existing testing knowledge into AI-assisted development earlier. Rather than viewing testing as a final checkpoint, organizations should adopt a tests-as-context approach that provides AI with relevant test cases and execution evidence and helps produce more reliable code from the start.  &lt;/p&gt;

&lt;h2&gt;
  
  
  When New Code Breaks Old Rules
&lt;/h2&gt;

&lt;p&gt;Even straightforward software development scenarios illustrate the shortcomings of current AI-assisted development practices. Consider an HR department that wants to automate employee onboarding. The software development team employs an AI coding assistant to help with this task. They provide it with product requirements documents (PRDs), Jira tickets, and design documents, allowing the assistant to begin building code for application access for new employees.&lt;/p&gt;

&lt;p&gt;However, the requirements documents omit an existing rule that employees cannot receive application access until their required approvals are completed. The regression suite captures this behavior, with tests confirming that accounts remain inactive while approvals are pending, and access is granted only after the necessary signoffs. The finished code, therefore, issues new employee credentials before required approvals are completed. When testing reveals this bug, software developers enter a cycle of rework and debugging to address the issue. &lt;/p&gt;

&lt;p&gt;The value of existing tests extends beyond hypothetical scenarios. One study found that providing security tests before code generation improved functional and security test success by &lt;a href="https://www.alphaxiv.org/abs/2608.09740" rel="noopener noreferrer"&gt;19.3 percentage points&lt;/a&gt; on average, although results varied across models and tasks. While this study takes a narrower angle, it highlights potential improvements in development if test artifacts and execution evidence are introduced earlier. Context can become a behavioral baseline that reduces downstream inefficiencies in current AI development practices.&lt;/p&gt;

&lt;h2&gt;
  
  
  Building with Behavioral Context
&lt;/h2&gt;

&lt;p&gt;Operationalizing a tests-as-context approach first requires software developers to identify the relevant test cases, data, and scripts for a certain project. They then must provide this context to the AI system before development begins. Before doing so, developers should confirm that the selected tests reflect current requirements and expected product behavior, rather than introducing outdated or incomplete information.&lt;/p&gt;

&lt;p&gt;Once developers identify applicable test artifacts, they can provide agents with execution evidence, recent execution results, failure logs, defect references, and environment details. This helps AI distinguish between expected and observed behavior and assess whether previous failures resulted from product defects or environmental issues.&lt;/p&gt;

&lt;p&gt;Throughout development, organizations can maintain traceability between the test assets agents interact with, their execution results, and the code changes they generate. This visibility is important to determine which behaviors were affected, so agents can run relevant tests throughout the development process and update the test suite with execution results.&lt;/p&gt;

&lt;p&gt;With context delivered up front, developers can reserve judgment for consequential touchpoints. They can verify that AI test case drafts are comprehensive, confirm that execution results align with expectations, and evaluate any corresponding edge cases. This will help developers prioritize higher-value work that AI is not yet prepared to tackle.&lt;/p&gt;

&lt;p&gt;Establishing these processes gives AI a stronger foundation for building functional code from the start. The technology has a better understanding of how code is supposed to operate in production, and developers can spend less time reworking AI outputs before code ships.&lt;/p&gt;

&lt;h2&gt;
  
  
  Same Feature, Different Outcome
&lt;/h2&gt;

&lt;p&gt;Consider the HR department example again, but this time through the lens of a tests-as-context approach. Developers identify relevant test case scripts, execution history, and run-environment information and deliver them to AI tools. AI leverages this information, along with the PRDs, Jira tickets, and design documents, to begin building.&lt;/p&gt;

&lt;p&gt;With the existing regression tests available before implementation, AI can account for the approval requirements as it develops the feature. Developers can then execute the relevant tests, review any failures, and confirm that the new code preserves existing access restrictions before approving the change. This reduces the need for downstream debugging and rework.&lt;/p&gt;

&lt;p&gt;Test artifacts and execution evidence already live inside the development process. By bringing this context earlier, developers can reduce unnecessary rework and gain greater confidence that AI-generated code preserves existing functionality.&lt;/p&gt;

</description>
      <category>testing</category>
      <category>ai</category>
      <category>devops</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>MCP, Context, and Agents: Building the AI-Native SDLC</title>
      <dc:creator>Chris Faraglia </dc:creator>
      <pubDate>Thu, 10 Sep 2026 14:14:03 +0000</pubDate>
      <link>https://dev.to/chris-faraglia/mcp-context-and-agents-building-the-ai-native-sdlc-b7i</link>
      <guid>https://dev.to/chris-faraglia/mcp-context-and-agents-building-the-ai-native-sdlc-b7i</guid>
      <description>&lt;p&gt;Everyone is aware of AI’s value in the software development lifecycle (SDLC). It can reduce repetitive work and accelerate development. As a result, over &lt;a href="https://www.infotech.com/research/ss/ai-adoption-impact-study-ai-in-software-development-june-2026-top-10-insights?" rel="noopener noreferrer"&gt;90%&lt;/a&gt; of surveyed developers have reported meaningful productivity gains while using the technology. These AI-related benefits often extend to individual testing tasks as well. It can create automation scripts, generate test cases, or prioritize which tests to run based on risk. Certain studies have reported a decrease of over &lt;a href="https://www.mdpi.com/2504-2289/10/7/233" rel="noopener noreferrer"&gt;60%&lt;/a&gt; in the time required for initial test creation.&lt;/p&gt;

&lt;p&gt;But faster individual tasks don't necessarily translate into better software quality, faster delivery, and more efficient use of AI forward tooling across the AI development lifecycle. Large language models can provide valuable software development intelligence, but the quality of their output is constrained by the context available for the specific domain, requirements, and task. Without product-specific context, an AI model may understand how software is generally written without understanding how a particular application is supposed to behave. That can lead to defects, debugging cycles, and rework that offset some of AI's initial productivity gains. &lt;/p&gt;

&lt;p&gt;Improving the AI SDLC therefore requires organizations to think beyond where AI is deployed and consider what information their AI tools can actually access. The goal should be to combine the right AI capabilities with the product, requirement, and testing context needed to make those capabilities effective.&lt;/p&gt;

&lt;p&gt;**&lt;/p&gt;

&lt;h2&gt;
  
  
  Faster Code, Bigger Blind Spots
&lt;/h2&gt;

&lt;p&gt;**&lt;/p&gt;

&lt;p&gt;The challenges in the AI SDLC usually fall into two overarching categories:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Extensive review cycles&lt;/strong&gt;: &lt;a href="https://www.infotech.com/research/ss/ai-adoption-impact-study-ai-in-software-development-june-2026-top-10-insights?" rel="noopener noreferrer"&gt;Two-thirds&lt;/a&gt; of developers say AI-generated code requires more testing than human-generated code. This is because AI models don’t inherently know how a specific product is supposed to behave in practice. These models often work from static specifications, such as Jira tickets or product requirement documents (PRDs), and can only build to exactly what is made available to them. As a result, the final product may not account for documented business rules, edge cases, historical failures, or regression tests, and development teams often have to fix defects in post.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Traceability gaps&lt;/strong&gt;: As AI-generated software creation accelerates, it also becomes harder to determine every component a change affects. This makes it difficult to relationships shifts across requirements, tests, and existing behavior, complicating the test strategy needed to ensure accuracy from the outset.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Ironically, the information needed to build toward the right behavior already exists. Testing context often captures how a product should function in practice, including the business rules, edge cases, and execution results that may not appear in the original requirements. The real issue is that this context is often scattered across systems, trapped in tribal knowledge, or brought into the development process too late.&lt;/p&gt;

&lt;p&gt;This is where context engineering becomes increasingly important. Rather than treating the prompt as the primary input to an AI system, context engineering focuses on assembling and continuously supplying the information the system needs to complete a specific task effectively. For software development, testing should be a key part of that strategy because test cases and results contain product-specific evidence about expected behavior that a general-purpose model cannot infer on its own.&lt;/p&gt;

&lt;p&gt;If organizations bring that testing context into AI development from the start, it can become part of the context-engineering foundation for the AI SDLC, helping teams build toward the right behavior and maintain traceability across requirements, tests, and code. The trick is figuring out how best to go about this.&lt;/p&gt;

&lt;p&gt;**&lt;/p&gt;

&lt;h2&gt;
  
  
  Connecting AI to the Testing Foundation
&lt;/h2&gt;

&lt;p&gt;**&lt;/p&gt;

&lt;p&gt;Testing infrastructure must become part of how AI builds, evaluates, and acts across the SDLC. Creating this groundwork often requires a deliberate progression:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Model context protocol (MCP)&lt;/strong&gt;: The first step in giving AI access to test cases, requirements, execution results, and the broader test plan is creating a secure, connected environment. That is what an MCP is often leveraged for and why it is becoming increasingly popular for AI-assisted development. Developers can pull relevant testing context into their existing workflows, and that base allows AI to query testing information in natural language, identify coverage gaps, generate tests from requirements, and feed results back into test suites.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Live context layer&lt;/strong&gt;: Once organizations establish a secure and connected infrastructure, testing has to shift from an end checkpoint to a continuous baseline throughout development. This means allowing test knowledge to continually inform AI about how a product should behave, and updating AI information as results and the product change. By being a “live” layer that establishes visibility across requirements, tests, and code, AI and developers can trace what AI actually touches and discover whether a new change might put an established function at risk before it reaches production.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AI agents&lt;/strong&gt;: Once validation becomes a part of development, in a secure and traceable manner, organizations can begin putting AI agents to work. While this is probably a longer-term goal, engineering teams could aim for AI to eventually execute most of the software quality workflow and software testing lifecycle (STLC). This means AI agents evaluate changes against applicable tests, surface risks, pinpoint missing coverage areas across the testing pyramid, automatically update test suites, and implement code against test-defined behaviors.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;With an integrated testing approach, an MCP could connect the AI environment to existing requirements, test cases, and execution results. The live context layer could fetch information relevant to scheduled ordering during development and trace all AI changes. Then AI agents could build the feature and execute applicable tests, bringing in humans to review only at outlined checkpoints. The result is that customers can schedule an order for 8:00 p.m., and developers can feel confident that the app still knows to assign a driver for pickup. &lt;/p&gt;

&lt;p&gt;Ultimately, the AI SDLC could move from isolated productivity improvements to a more connected and effective software creation cycle.&lt;/p&gt;

&lt;p&gt;**&lt;/p&gt;

&lt;h2&gt;
  
  
  From Assistance to Autonomy
&lt;/h2&gt;

&lt;p&gt;**&lt;/p&gt;

&lt;p&gt;AI’s place in the SDLC is already useful. However, it has not reached its full potential. Using testing knowledge as a backbone of an organization's context-engineering strategy can give AI a more reliable foundation for understanding product-specific behavior. Connecting AI to that knowledge, turning it into live context, and eventually enabling agents to act on it could transform isolated efficiencies into faster development cycles, fewer defects, less rework, and increasingly autonomous workflows. &lt;/p&gt;

&lt;p&gt;As those workflows become more autonomous, maintaining that trusted testing context will become increasingly important to preserving software quality and confidence in the actions AI takes. Then organizations can devote more of their time to higher-value work. More importantly, AI no longer has to determine what “correct” means on its own.&lt;/p&gt;

</description>
      <category>testing</category>
      <category>qa</category>
      <category>devops</category>
      <category>mcp</category>
    </item>
  </channel>
</rss>
