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

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 very easy to accept AI-generated code that appears polished but hides underlying issues. However, speed without quality doesn’t help you ship faster, it just increases the risk of issues compounding down the road. That’s why the teams and organizations that succeed are the ones that pair AI-driven velocity with real guardrails.

And that’s exactly what GitHub Code Quality (currently in public preview) helps you do. GitHub Code Quality is an AI- and CodeQL-powered analysis tool that surfaces maintainability issues, reliability risks, and technical debt across your codebase, right as you work. Here’s how to start using it:

1. 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. This will give you a clear view of the maintainability and reliability issues in your codebase.
   
2. 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. Here’s an example of pull request code that “works,” but isn’t production-ready:

// 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);

GitHub Code Quality responds with AI + CodeQL-powered suggestions, including a one-click 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.

3. Enforce your quality bar
   Rulesets let you block merges that don’t meet your team’s standards. This keeps quality consistent without relying on reviewer willpower and without killing your velocity.
4. Reveal (and fix) legacy technical debt
   The AI Findings page highlights issues in files your team is already working in, helping you fix problems while they’re top of mind and reduce context switching.

Bottom line: AI gives you speed. GitHub Code Quality gives you control. Together, they let you move faster and build better without ever 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 has never come from automation alone. GitHub has always believed in giving you the tools to write your best code—from Copilot in the IDE, to GitHub Copilot code review in pull requests, to GitHub Code Quality—providing visibility into long-standing issues and tech debt, along with actionable fixes to help you address them.

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

Here’s a simple prompting framework that helps you do just that:

1. Set the goal, not just the action
   Think of your prompts like giving direction to another engineer: the more clarity you provide, the better the final output. 

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
   Examples:
   • “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 format of the output
   Pull request, diff, patch, commentary, or code block.

With GitHub Copilot coding agent, you can even assign multi-step tasks like:

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

Notice how you remain accountable for the thinking and the agent becomes accountable for the doing.

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

Learn more about coding agent 👉

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

As AI takes on more execution work, what sets effective developers apart is how clearly they communicate decisions, trade-offs, and reasoning. It’s no longer enough to write code, you need to show how you think, evaluate, and approach problems across the lifecycle of a feature. 

Here’s a best practice to level up your documentation signal: 

1. Create an issue that captures the why
   Write a brief summary of the problem, what success looks like, constraints, and any risks.
   
2. Name your branch clearly and commit thoughtfully
   Use meaningful names and commit messages that narrate your reasoning, not just your keystrokes.
   
3. Use Copilot and coding agent to build, then document decisions
   Include short notes on why you chose one approach over another and what alternatives you considered.
   
4. Open a pull request with signal-rich context
   Add a short “Why,” “What changed,” and “Trade-offs” section, plus screenshots or test notes.

For example, instead of:

Added dark mode toggle

Try this:

- Added dark mode toggle to improve accessibility and user preference support.
- Chose localStorage for persistence to avoid server dependency.
- Kept styling changes scoped to avoid side effects on existing themes.

Bottom line: Your code shows what you did, but your documentation shows why it matters. In this new AI era, the latter is just as critical as the former.  

Learn more about effective documentation 👉

Moving forward together 

At the end of the day, quality is everything. While AI may accelerate the pace of work, it can also turn that speed on its head if the output isn’t guided with intent. But when you combine AI with clear direction, strong guardrails, and visible thinking, you help your team deliver cleaner, more reliable code at scale—and position your organization to move quickly without compromising on what matters most.

The post Speed is nothing without control: How to keep quality high in the AI era appeared first on The GitHub Blog.