How Normal Software Engineers Actually Use AI in Their Daily Work

Let's cut through the hype. You're not building the next AGI. You're a working software engineer with deadlines, legacy code, and a backlog that never shrinks. So how do you actually use AI tools in your day-to-day work?

After surveying hundreds of developers and reflecting on real-world usage patterns, here's what normal software engineers are doing with AI—no Silicon Valley theatrics required.

The Mundane But Invaluable: Code Completion and Boilerplate

The most common use case is the least sexy: letting AI handle repetitive code. GitHub Copilot, Cursor, and similar tools excel at generating boilerplate that you'd otherwise copy-paste from Stack Overflow or previous projects.

Real example: Writing CRUD endpoints in Express/TypeScript:

typescript

// Type this comment and let AI complete:

// Create a REST endpoint for user registration with email validation

app.post('/api/users/register', async (req: Request, res: Response) => {

try {

const { email, password, name } = req.body;

// Email validation

const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

if (!emailRegex.test(email)) {

  return res.status(400).json({ error: 'Invalid email format' });

}



// Check if user exists

const existingUser = await User.findOne({ email });

if (existingUser) {

  return res.status(409).json({ error: 'User already exists' });

}



// Hash password and create user

const hashedPassword = await bcrypt.hash(password, 10);

const user = await User.create({ email, password: hashedPassword, name });



res.status(201).json({ userId: user.id, email: user.email });

} catch (error) {

res.status(500).json({ error: 'Internal server error' });

}

});

Did AI write perfect code? No. But it gave you scaffolding to refine, saving 10-15 minutes of typing. That's the real win.

The Game-Changer: Explaining Legacy Code and Obscure APIs

Every developer inherits someone else's mess. AI tools shine when deciphering undocumented code or unfamiliar libraries.

Practical workflow:

1. Copy confusing code snippet into ChatGPT or Claude


2. Ask: "Explain what this code does and identify potential issues"


3. Follow up: "How would you refactor this for better readability?"

This works especially well for:

• Complex regex patterns


• Functional programming constructs in codebases you didn't write


• AWS/GCP service configurations


• Database query optimization

Example prompt I use weekly:

"This Python decorator is using functools.wraps and managing some state. Walk me through what's happening step-by-step, then suggest if there's a cleaner approach."

The AI explanation often surfaces edge cases or anti-patterns you'd miss during a rushed code review.

The Productivity Multiplier: Writing Tests and Documentation

Developers hate writing tests and docs. AI doesn't. Use this to your advantage.

For test generation:

python

Original function

def calculate_discount(price: float, user_tier: str, promo_code: str = None) -> float:

base_discount = {"bronze": 0.05, "silver": 0.10, "gold": 0.15}.get(user_tier, 0)

discount = price * base_discount

if promo_code == "SAVE20":


    discount += price * 0.20



return min(discount, price)

Prompt AI: "Write pytest tests covering edge cases for this function"

You'll get:

import pytest

def test_calculate_discount_bronze_tier():

assert calculate_discount(100, "bronze") == 5.0

def test_calculate_discount_invalid_tier():

assert calculate_discount(100, "platinum") == 0.0

def test_calculate_discount_with_promo():

assert calculate_discount(100, "silver", "SAVE20") == 30.0

def test_discount_never_exceeds_price():

assert calculate_discount(10, "gold", "SAVE20") == 10.0

def test_calculate_discount_zero_price():

assert calculate_discount(0, "gold") == 0.0

AI-generated tests aren't comprehensive, but they give you 70% coverage in seconds. You add the remaining edge cases yourself.

For documentation: Paste your function and ask for JSDoc or docstring format. Instant improvement over no documentation.

The Debugging Assistant: Rubber Duck 2.0

When Stack Overflow fails and your senior dev is in meetings, AI becomes your debugging partner.

Effective debugging prompts:

• "I'm getting TypeError: Cannot read property 'map' of undefined in React. Here's my component. What am I missing?"


• "This PostgreSQL query times out on large datasets. Here's the schema and query. Suggest optimizations."


• "My Docker container builds locally but fails in CI. Here's the Dockerfile and error log."

The key is providing context: error messages, relevant code, and what you've already tried. AI tools are pattern-matching machines—give them patterns to match.

The Automation Enabler: Generating Scripts and Configs

Need a one-off script to migrate data? Parse logs? Set up CI/CD? AI writes the first draft while you drink coffee.

Real automation example:

"Write a Python script that reads a CSV of user emails, checks if each user exists in our Postgres database, and outputs a report of missing users."

You get working code in 30 seconds. Maybe it needs tweaks for your schema, but you've eliminated the "blank page problem."

This extends to configuration files:

• GitHub Actions workflows


• Terraform configurations


• ESLint and Prettier configs


• Docker Compose setups

Why memorize YAML syntax for the hundredth time when AI can generate it?

What AI Doesn't Replace (Yet)

Be realistic about limitations:

• 
  Architectural decisions: AI can't understand your business requirements or scaling needs


• 
  Code review judgment: It misses context about team conventions and product strategy


• 
  Complex debugging: Multi-service interaction bugs require human reasoning


• 
  Security implications: AI suggests code that works but might have vulnerabilities

Treat AI as a junior developer: fast at boilerplate, helpful for brainstorming, needs supervision for production code.

The Toolset That Actually Matters

Here's what normal developers use (not a sponsored list):

1. 
   GitHub Copilot - Best for inline code completion


2. 
   ChatGPT/Claude - Best for explanations and architecture discussions
   


3. 
   Cursor - VSCode fork with AI deeply integrated


4. 
   v0.dev - React component generation (when prototyping)


5. 
   Phind - Developer-focused search with AI summaries

Most developers use 2-3 of these, not all. Pick what fits your workflow.

Conclusion: Use AI Like a Tool, Not Magic

The developers getting real value from AI aren't waiting for it to write entire applications. They're using it to:

• Skip boilerplate


• Understand unfamiliar code faster


• Generate test scaffolding


• Debug with a second perspective


• Automate one-off tasks

This saves 30-60 minutes daily—time spent on actual problem-solving instead of syntactic overhead.

The question isn't "Does AI replace developers?" It's "Are you using AI to avoid the boring parts of your job?" If not, you're working harder than necessary.

Start small. Pick one repetitive task this week and let AI handle it. Build from there. The future isn't about AI doing your job—it's about you doing more interesting work because AI handles the grunt work.

Now stop reading and go automate something.

🛠 Recommended Tools

• 
  by Tom Taulli


• 
  The Pragmatic Programmer: Your Journey to Mastery by David Thomas and Andrew Hunt

These are affiliate links — if you buy through them I earn a small commission at no extra cost to you.