How Developers Fix "Bugs" Before vs After the World of Agentic AI

To a user or a customer, software can feel magic, pages that loads with images for them to click on, drop down menus with simple choices, and options to customize and create what they want, with no programming required on them. When a button freezes, a feature request drops, or a minor layout tweak is needed, the perception is almost always the same: “It’s just a quick change. Can’t a developer just jump into the code and fix it right now?”

In the minds of most non-technical stakeholders, changing software is like editing a shared Google Doc—you open the file, type the correction, hit save, and everyone instantly sees the update. But in professional software engineering, the "quick fix" is a dangerous myth.

Behind every single button, dropdown, and image upload sits a massive, interconnected ecosystem of code, HTTPs calls, databases, and servers. Even the smallest modification—whether it is building a highly anticipated new feature or fixing a minor, nagging bug—cannot simply be typed directly into the live software. If a developer did that, a single typo could instantly crash the entire platform for thousands of global users. Also, there would be no way to test it before it went "live" for everyone.

Instead, every single code change must pass through a strict, highly calculated, and multi-layered pipeline designed to enforce security, prevent system outages, and ensure quality control. A request must be formally tracked, isolated on a developer's local machine entirely separate from the main codebase, rigorously reviewed by peers, tested in a simulated "QA" playground, and safely deployed to production.

The Tools Used

Let's look behind the curtain of a modern development team using Jira, Visual Studio Code (VS Code), Git and GitHub to see exactly how a standard customer bug report is resolved and pushed to a Quality Assurance (QA) environment. First let's look at how this process happens without agentic AI and then let's compare it to the workflow using agentic AI.

Jira is a highly customizable project and issue management software developed by Atlassian. It allows teams to plan, track, and manage their daily workflows and is very popular for development teams.
Visual Studios Code is a comprehensive software program created by Microsoft. It is an Integrated Development Environment (IDE) used by programmers to write, edit, debug, test, and deploy applications, websites, web services, and mobile apps.
Git (different than Github)is a free, open-source distributed version control system designed to track changes in source code and files over time. The 3 Stages of Saving Code in Git: When files are changed in a project, Git tracks them but doesn't save them right away. It uses a three-step process:
- Modified State: The files are changed, but Git considers them "unstaged" (unsaved drafts).
- Staged State (The "Staging Area"): You select exactly which changed files you want to include in your next save snapshot. It is like placing items into a shipping box before taping it shut.
- Committed State: The snapshot is permanently saved to the project's history.

Before Agentic AI

First let's look at the steps for this process before AI, especially Agentic AI.

Step 1: Triage and Assignment in Jira

The journey begins when a customer submits a support ticket: "When I upload a new profile picture and click 'Save,' the button freezes and nothing happens."The QA or support team replicates the issue and logs a formal bug ticket in Jira, the team's project management platform. Jira automatically assigns the ticket a unique identifier, such as ENG-501, and tags it as a high-priority bug. The engineering manager assigns ENG-501 to a developer, who flips the ticket status from "To Do" to "In Progress" so the rest of the company knows the issue is being handled.

Step 2: Preparing the Sandbox in VS Code (Git)

The developer opens Visual Studio Code (VS Code) on their laptop. Before writing a single line of new code, they must ensure their local machine has the absolute latest version of the company’s codebase. Instead of typing text commands into a separate terminal, the developer opens VS Code's built-in Source Control panel (powered by Git). With a few clicks, they perform two vital steps:

Pull the Latest Code: They download the most recent, clean copy of the production code (the main branch) from GitHub onto their laptop.
Create a Feature Branch: They spin up a brand-new, isolated code branch named bugfix/ENG-501-profile-save.

By naming the branch after the Jira ticket ID (ENG-501), a background integration bridges the two platforms, automatically logging the developer’s active coding branch inside the Jira ticket overview for the project manager to see.

Step 3: Fixing the Bug Locally

Working entirely inside their isolated ENG-501 branch, the developer (or his/her agent) investigates the code. They find the culprit: the code responsible for processing user profiles crashes whenever it encounters raw image files, and because there is no error safety-net in place, the "Save" button simply freezes on the screen. The developer (or agent) rewrites the logic to safely convert the image file into a clean cloud URL string and adds proper error-handling to the frontend. They/their agent runs the software locally on their machine, uploads a test photo, clicks save, and confirms that it now works perfectly.

Step 4: Staging, Committing, and Pushing

Now that the fix is verified locally, the developer/their agent needs to package their changes. They return to the Source Control panel in VS Code:

Staging: They click a plus icon next to the modified files to "stage" them, telling the system exactly which files are part of this fix.
Committing: They type a clear description into the commit text box: "fix: resolved profile save button freeze on image upload [ENG-501]" and click Commit. This saves a permanent snapshot of the fix to their laptop's internal history.
Pushing: They click the Publish Branch (or Sync) button. VS Code fires up a background network command (git push) to securely upload this new branch from the developer's laptop to the team's central repository cloud on GitHub. Github is a cloud-based platform where developers store, share, and collaborate on software code. It acts as a central hub (or "Google Drive for code") where teams can track changes, review each other's work, and build projects together without overwriting each other's files

Step 5: The GitHub Pull Request & Peer Review

The code is now in the cloud, but it is still strictly isolated within the bugfix/ENG-501 branch. To merge it into the official codebase, the developer logs into GitHub and clicks "New Pull Request" (PR).A Pull Request is essentially a formal request to merge the fix into the main branch, and it opens a dedicated review timeline for the team. The moment the PR is created, two critical things happen simultaneously:

Automated Testing (CI/CD): GitHub Actions automatically wakes up. It boots up a temporary, isolated cloud server, compiles the team's application, and runs hundreds of pre-written automated tests to ensure the developer's new code didn't accidentally break something else in the software ecosystem.
Peer Review: A senior developer is assigned to audit the changes. They open the GitHub PR page, which displays a color-coded, line-by-line comparison of exactly what the developer changed. They check for security vulnerabilities, formatting errors, and overall logic.

Step 6: Approval, Merging, and QA Deployment

Once the automated tests display a successful green checkmark and the senior developer is satisfied with the code quality, the reviewer clicks "Approve" and hits the green "Merge Pull Request" button.GitHub instantly absorbs the C# and JavaScript changes into the official main branch codebase. This merge automatically triggers a final automation pipeline: it packages the updated application and deploys (installs) it directly onto the team's QA (Quality Assurance) Environment servers.Back on the project board, the Jira integration recognizes the successful GitHub merge and automatically advances the ENG-501 ticket from "In Review" to "Ready for QA." The internal testing team is notified that the fix is live in the sandbox environment and ready for final manual testing before it is safely released to real-world customers.

Now let's look at the steps that many developers are taking with the help of AI.

After Agentic AI

The traditional software pipeline ensures safety and quality, but manually navigating between Jira, codebase files, terminals, and testing suites takes hours. Today, developers are using Agentic AI—autonomous Large Language Models (LLMs) running inside developer platforms like OpenCode—to act as an intelligent co-pilot. Instead of just suggesting code snippets, these agents can connect to external tools, navigate full-stack architectures, run tests, and manage the Git workflow. Here is exactly how a developer uses an AI agent in OpenCode alongside Visual Studio, Jira, and GitHub to resolve our full-stack profile picture bug.

Step 1: AI Triage and Context Gathering

The process begins when a new bug lands in Jira: ENG-602: Save profile button freezes on image upload.

The AI Step: The developer opens OpenCode and prompts the AI agent: "Analyze and start working on Jira ticket ENG-602."
The Action: Using secure API tokens, the AI agent logs into Jira, reads the ticket description, and analyzes the customer's bug report. It recognizes that the issue involves a frontend action (React), an API call (Python), and a database state (Postgres).
Important: When agents are doing this same type of work over and over again, good developers create a detailed guide for the agent to reference each time so that the work that the agent does is the same and correct every time, following any needed rules and staying in any needed guardrails.

Step 2: Autonomous Codebase Scanning

Instead of the developer spending an hour manually searching through thousands of files, the AI takes over.

The Action: The agent scans the team's repository. It traces the data flow from the React UI components down to the Python routes and Postgres schemas.
The AI Discovery: Within seconds, the AI flags the exact root cause: the React component lacks error-handling, the Python backend crashes because it is trying to pass raw binary image data into a standard text column, and the Postgres table layout needs an update to properly store image URLs.

Step 3: Generating a Full-Stack Fix for Review

Before modifying anything, the AI compiles a detailed architectural proposal right inside the developer's interface.

The Action: The agent presents a side-by-side view outlining the exact changes needed across all three layers:
1. Frontend (React): A patch to add a loading spinner and an error safety-net to the save button.
2. Service Layer (Python): A rewrite of the endpoint to securely send the image to cloud storage and pass a clean URL string forward.
3. Database (PostgreSQL): A migration script ensuring the profile_picture_url column is ready to receive text data.
The Developer's Role: The developer reviews the AI's proposal inside Visual Studio. Because the AI did the heavy lifting of diagnosing the system, the developer simply reads the suggestion, verifies the logic looks safe, and tells the agent "Approve & Apply."

Step 4: Branch Isolation and Automated Testing

The moment the developer approves the plan, the AI acts as an autonomous engineer inside the local workspace.

The Action: The AI automatically interacts with Git in the background to pull the latest production code and spin up a new local branch named bugfix/ENG-602-profile-upload. It injects the approved React, Python, and SQL changes (depending on what changes are needed to fix the reported bug) directly into Visual Studio.
The Automation (Playwright): If prompted (or told in a guideline), the agent doesn't just write code; it ensures it works. It spins up an automated Playwright testing suite in the background. The AI script simulates a fake user browser, uploads a mock profile picture, and clicks "Save."
The Result: Playwright confirms the UI no longer freezes and the database updates successfully. It passes the green test logs back to the developer. (If a edge-case fails, the AI flags it for the developer to perform a quick manual check).

Step 5: AI-Driven Git Staging and Commit

With the code fully validated, the AI prepares the code package.

The Action: The agent automatically runs the staging commands inside the workspace's Git environment. Meaning the AI agent interacts with the Git software installed on the developer's computer to prepare the modified files for saving, doing the exact same manual work a human developer would usually do in their computer terminal or code editor, like Visual Studios.
The Commit: It writes a highly descriptive, professional commit message referencing the Jira ticket: fix(profile): handle binary image uploads via cloud storage buckets and prevent UI freeze [ENG-602]. It then executes the local commit and pushes the branch to GitHub
- Github is a cloud-based platform where developers store, share, and collaborate on software code. It acts as a central hub (or "Google Drive for code") where teams can track changes, review each other's work, and build projects together without overwriting each other's files).
The guideline that the agent references should explain how each commit message should be structured.

Step 6: GitHub PR Creation & Jira Status Sync

The final step bridges the technical code with the project management tracking.

The Action: The AI agent communicates directly with GitHub's API to open a Pull Request. It fills out the PR description automatically, summarizing the full-stack fixes and attaching the successful Playwright test results as proof of stability.
The Jira Update: The agent instantly loops back to Jira. It leaves an automated comment on the ticket: "AI Agent Update: Branch created, full-stack fix applied, Playwright tests passed, and GitHub PR #42 opened for peer review." It automatically advances the Jira ticket status column to "In Review."

The New Reality for Finding & Fixing Bugs

By offloading the tedious discovery, multi-file updating, local testing, Git commands, and pull request to the Agentic AI, the developer never had to leave Visual Studio or spend time hunting for broken syntax. The developer's role shifts from a mechanical code-writer to an architectural reviewer or agentic engineer, validating the AI's plan and letting automation handle the pipeline. This is a clear example of how agentic AI can help a person do their job faster and better. It doesn't replace the person, it empowers them to work at a higher level and faster, which ultimately leads to more work being done by each developer and overall greater output by the team.