AI-Assisted Software Engineering

Understand how coding assistants work, what each mode offers, and where each tool fits in a developer workflow.

• Autocomplete, chat, and agent modes compared
• GitHub Copilot, Cursor, and Claude Code: strengths and trade-offs
• Context windows and why repository context matters
• Where assistants help most and where they mislead
• Setting up editors, extensions, and project instruction files
• Data and privacy settings to check before first use

Hands-on lab: Install two assistants, complete the same small feature task with each, and record time, accuracy, and review effort in a comparison table.

Learn to give assistants the context, constraints, and examples that produce usable code.

• Stating intent, inputs, outputs, and constraints explicitly
• Supplying relevant files, types, and conventions as context
• Iterating with small steps instead of one large request
• Asking for a plan before code
• Using examples and existing patterns to match style
• Recognizing when to stop prompting and write it yourself

Hands-on lab: Implement a small API endpoint using three prompt styles, from vague to fully specified, and score each result against the same acceptance checklist.

Use assistants to produce meaningful tests and treat tests as the safety net for AI-written code.

• Generating unit tests from function signatures and behavior
• Prompting for edge cases, error paths, and boundary values
• Test-first prompting: tests before implementation
• Spotting weak or tautological assistant-written tests
• Mocking external services without hiding real bugs
• Using coverage as a signal, not a goal

Hands-on lab: Generate tests for an existing module, seed three bugs, and check how many your generated suite catches before improving it by hand.

Apply assistants to understand, document, and safely modernize code you did not write.

• Having an assistant explain unfamiliar modules and call paths
• Characterization tests before changing legacy behavior
• Small-step refactors: extract function, rename, simplify conditionals
• Language and framework migration in incremental slices
• Generating documentation and docstrings, then verifying them
• Limits of multi-file agent edits and how to constrain them

Hands-on lab: Take a provided legacy module, write characterization tests, then refactor it with an assistant in at least four verified commits.

Combine human judgment with assistant support to review changes and track down defects.

• Using assistants to summarize pull requests and flag risks
• A reviewer checklist for AI-generated changes
• Reading stack traces and logs with assistant help
• Forming hypotheses and verifying them rather than accepting a guess
• Detecting plausible but non-existent APIs and packages
• Keeping pull requests small and explainable

Hands-on lab: Review a pull request containing subtle AI-introduced flaws, log every issue you find, and compare your list with an assistant-generated review.

Identify the security and licensing risks specific to AI-generated code and build guardrails around them.

• Common vulnerability patterns in generated code, such as injection and weak input validation
• Hallucinated dependencies and supply-chain risk
• Keeping secrets, credentials, and customer data out of prompts
• Static analysis and dependency scanning in CI
• Prompt injection through repository files and issues when using agents
• Licensing and attribution questions to raise with your organization

Hands-on lab: Audit a generated service for vulnerabilities, add a security scan and secret check to a GitHub Actions workflow, and fix each finding.

Turn individual habits into shared team practices and apply them end to end on a final project.

• Project instruction files and shared prompt libraries
• Defining when AI assistance is expected, allowed, or restricted
• Review and attribution conventions for AI-assisted commits
• Onboarding teammates and sharing effective patterns
• Tracking whether assistants help using your own team's measures
• Presenting engineering work and trade-offs to stakeholders

Hands-on lab: Deliver your capstone feature with tests and a security check, then present your team AI-usage guidelines and receive peer review.