Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
AI Coding for Software Engineers: Prompt, Test & Verify
New
Rating: 5.0 out of 5(2 ratings)
2 students

AI Coding for Software Engineers: Prompt, Test & Verify

Write better prompts, use context wisely, compare models, and verify AI-assisted code in a realistic project.
Last updated 10/2026
English
English

What you'll learn

  • Write testable engineering prompts with explicit scope, constraints, and success checks.
  • Build a concise context pack and interpret task-level token usage without making unsupported cost claims.
  • Read coding benchmarks critically and run a task-specific model comparison.
  • Use a coding agent within a defined authority boundary and review its patch independently.
  • Reproduce bugs, design tests that can fail, and probe AI-generated code for overlooked edge cases.
  • Produce an evidence-backed runbook, capstone report, and release/hold decision.

Course content

8 sections • 38 lectures • 2h 11m total length
  • Diagnose a Duplicate-Event Bug and Verify the AI Fix4:44

    Follow a duplicate webhook retry bug from a failing test to an AI-assisted patch. See why the first green result still misses a race, and how a database guard plus an independent HTTP check changes the verdict.

  • Practice 1.1 - Reproduce the Retry Bug and Check Database Uniqueness3:17

    Download the exercise ZIP, tour its files, run the red and green checks, and send a duplicate HTTP retry. Record evidence showing whether one event produces only one durable database row.

  • Find the Hidden Failure in a Green AI Patch3:45

    A passing sequential test can hide a broken database guarantee. Compare what the test suite proves with a direct duplicate-row probe, then decide whether the AI fix should be accepted.

  • Practice 1.2 - Challenge a Passing Test with a Database Probe2:02

    Use the short exercise ZIP to run three checks and inspect the database directly. Make an accept-or-reject decision based on the duplicate-row evidence, not the agent's confident summary.

  • Plan, Patch, and Verify with ChatGPT and Codex4:26

    Watch a no-edit ChatGPT plan become a bounded Codex task for a blank-summary validation bug. Compare the agent's change with the unchanged tests and a direct localhost check before calling the work complete.

  • Practice 1.3 - Fix a Validation Bug with a Plan, Agent Patch, and Tests3:55

    Explore the supplied project, reproduce the validation defect, write a no-edit plan and a bounded patch request, then run the tests and localhost probe. Finish with a short report explaining what passed and where to stop.

Requirements

  • Comfortable reading basic Python code and running terminal commands.
  • An AI assistant is optional for the full hands-on agent steps; no specific paid subscription is required to watch and understand the course.

Description

This course contains the use of artificial intelligence.


AI can draft code in seconds. The hard part is deciding what to ask, how much context to provide, and whether the answer survives a real test. If you have ever accepted a plausible AI patch and later found a regression, this course gives you a practical engineering workflow for doing better.

You will work through a small, synthetic Python web service called RelayDesk. The course shows the actual requests made to AI assistants and coding agents, edited into readable evidence walkthroughs. You will see a duplicate-event bug, a first green patch that still misses a database invariant, a bounded feature request, an old-schema failure, a review-found boundary bug, and an evidence-backed capstone handoff. These are local educational exercises, not claims about a production service or a human typing live on screen.


Here is what you will practice:

- Turn vague requests into prompts with a clear task, relevant context, constraints, and verification criteria.

- Give an agent enough repository evidence without dumping unrelated files; measure usage and avoid confusing session token counts with an API bill.

- Read coding benchmark methodology, identify what a leaderboard cannot prove, and run a fair local comparison on your own task.

- Limit an agent's authority, inspect its changes, reproduce red tests, and independently verify the result.

- Find flaws that a green test suite misses: database uniqueness, old schemas, data exposure, pagination, retries, and boundary behavior.

- Write a runbook and a release decision that distinguish a locally working teaching reference from a production-ready change.


Each section includes a guided practice video and a downloadable project ZIP. You can inspect the folders and files, run the supplied checks, write your own AI request, compare your result with a reference, and record the evidence you would show another engineer. The final capstone combines prompt design, implementation, adversarial review, repair, and a clear statement of remaining risk.


The course is intentionally focused on engineering judgment, not model hype or a promise of autonomous deployment. The examples use a local coding-agent workflow and a synthetic Python service; the principles transfer to other assistants and stacks. Interfaces, model rankings, and prices can change, so you will learn how to evaluate them rather than memorize a fixed winner.

This course is a good fit if you can read a small codebase and run basic terminal commands. You do not need prior professional experience with AI. Bring a computer, Python for the exercises, and optional access to an AI assistant if you want to perform the agent steps yourself. You can still follow the included evidence without a paid model account.

My goal is for you to finish with a repeatable loop: define the task, choose the evidence, write a bounded request, inspect the output, challenge it, and hand off what you can actually prove.

Who this course is for:

  • Software engineers and developers who already code but want a more reliable AI-assisted workflow.
  • Backend, platform, DevOps, and test engineers who need to verify generated changes.
  • Technical leads who want a concrete review standard for AI-assisted patches.