Speed is nothing without control: How to keep quality high in the AI era

Source: GitHub Blog

What’s the point of moving faster if you can’t trust the code you’re shipping?

We’ve all been using AI in our workflows for a while now, and there’s no denying how much faster everyday development has become. Tasks that once took hours now finish in minutes. Entire features come together before you’ve even finished your morning coffee.

But we’ve also experienced the other side of that speed: when AI is used without clear direction or guardrails, it can generate what’s often called AI slop—semi‑functional code stitched together without context, quietly piling up bugs, broken imports, and technical debt.

In this new era, being fast isn’t enough. Precision and quality are what set teams apart.

“The best drivers aren’t the ones who simply go the fastest, but the ones who stay smooth and in control at high speed,” said Marcelo Oliveira, GitHub VP of product at GitHub Universe 2025. “Speed and control aren’t trade‑offs. They reinforce each other.”

So how do you get the best of both? How do you move fast and keep your code clean, reliable, and firmly under your direction? Here are three essential strategies.

Tip #1: Treat speed and quality as a package deal

It’s easy to accept AI‑generated code that looks polished but hides underlying issues. Speed without quality doesn’t help you ship faster; it just increases the risk of compounding problems. Successful teams pair AI‑driven velocity with real guardrails.

GitHub Code Quality (currently in public preview) is an AI‑ and CodeQL‑powered analysis tool that surfaces maintainability issues, reliability risks, and technical debt across your codebase, right as you work.

Enable with one click

Turn it on at the repository level and GitHub will analyze your code using a combination of CodeQL and LLM‑based detection, giving you a clear view of maintainability and reliability issues.

Get automatic fixes inside every pull request

As soon as you open a pull request, GitHub Code Quality flags unused variables, duplicated logic, runtime errors, and more.

Example of problematic code

// fuelCalculator.js
export function calculateFuelUsage(laps, fuelPerLap) {
  const lastLap = laps[laps.length - 1]; // unused variable

  function totalFuel(laps, fuelPerLap) {
    return laps.length * fuelPerLap;
  }

  // duplicated function
  function totalFuel(laps, fuelPerLap) {
    return laps.length * fuelPerLap;
  }

  return totalFuel(laps, fuelPerLap);
}

AI‑generated fix

-export function calculateFuelUsage(laps, fuelPerLap) {
-  const lastLap = laps[laps.length - 1]; // unused variable
-
-  function totalFuel(laps, fuelPerLap) {
-    return laps.length * fuelPerLap;
-  }
-
-  // duplicated function
-  function totalFuel(laps, fuelPerLap) {
-    return laps.length * fuelPerLap;
-  }
-
-  return totalFuel(laps, fuelPerLap);
-}
+export function calculateFuelUsage(laps, fuelPerLap) {
+  if (!Array.isArray(laps) || typeof fuelPerLap !== "number") {
+    throw new Error("Invalid input");
+  }
+  return laps.length * fuelPerLap;
+}

No triage or slowdown—just clean, reliable code.

Enforce your quality bar

Rulesets let you block merges that don’t meet your team’s standards, keeping quality consistent without relying on reviewer willpower.

Reveal (and fix) legacy technical debt

The AI Findings page highlights issues in files your team is already working on, helping you fix problems while they’re top of mind and reducing context switching.

Bottom line: AI gives you speed. GitHub Code Quality gives you control. Together, they let you move faster and build better without trading one for the other.

Learn more about GitHub Code Quality

Tip #2: Be the driver, not the passenger

AI can generate code quickly, but quality never comes from automation alone. GitHub provides tools—from Copilot in the IDE to Copilot code review in pull requests and GitHub Code Quality—that give you visibility into long‑standing issues and actionable fixes.

These features let you set direction, standards, and constraints. The clearer your intent, the better AI can support you.

Prompting framework

1. Set the goal, not just the action
   Bad prompt:

   refactor this file

   Better prompt:

   refactor this file to improve readability and maintainability while preserving functionality, no breaking changes allowed

2. Establish constraints

   • “No third‑party dependencies”
   • “Must be backwards compatible with v1.7”
   • “Follow existing naming patterns”

3. Provide reference context
   Link to related files, docs, existing tests, or architectural decisions.

4. Decide the output format
   Pull request, diff, patch, commentary, or code block.

Multi‑step task with a coding agent

Create a new helper function for formatting currency across the app.
- Must handle USD and EUR
- Round up to two decimals
- Add three unit tests
- Do not modify existing price parser
- Return as a pull request

You remain accountable for the thinking; the agent handles the doing.

Bottom line: AI accelerates execution, but your clarity—and GitHub’s guardrails—turn that acceleration into high‑quality software.

Learn more about the coding agent

Tip #3: Build visible proof of your thinking, not just your output

As AI takes on more execution work, effective developers stand out by clearly communicating decisions, trade‑offs, and reasoning. It’s no longer enough to write code; you need to show how you think, evaluate, and approach problems throughout a feature’s lifecycle.

Best‑practice checklist

• Create an issue that captures the why
  Write a brief summary of the problem, success criteria, constraints, and any risks.

• Name your branch and commit thoughtfully
  Use meaningful names and commit messages that narrate your reasoning, not just your keystrokes.

• Use Copilot and the coding agent to build, then document decisions
  Include short notes on why you chose one approach over another and what alternatives you considered.

• Open a pull request with signal‑rich context
  Add “Why,” “What changed,” and “Trade‑offs” sections, plus screenshots or test notes.

Example

Instead of a vague commit message:

Added dark mode toggle

Provide richer context:

- Added dark mode toggle to improve accessibility and user preference support.
- Chose localStorage for persistence to avoid server dependency.
- Scoped styling changes to prevent side effects on existing components.
- Added unit tests for toggle state persistence and UI rendering.

By documenting the “why” alongside the “what,” you create a transparent trail that helps teammates, future maintainers, and automated tools understand and trust the code you ship.