AI is changing software development at a deeper level than faster code completion. Modern coding agents can inspect a repository, plan a change, edit several files, run commands, execute tests and prepare work for review. Used well, they can shorten feedback cycles and give developers more time for design and problem-solving. Used carelessly, they can create large volumes of code that nobody fully understands.
This course establishes the working practices needed for AI-native development. Rather than concentrating on one vendor or product, it teaches transferable techniques for defining work, providing context, supervising execution and verifying results. Participants will use coding agents on realistic development tasks while retaining clear ownership of architecture, security and quality.
The aim is not to remove developers from the process. It is to help them decide what to delegate, what to control deterministically and where human judgement remains essential.
Learning Outcomes
Upon completion of this course, participants will be able to:
- Explain the differences between code completion, conversational assistance and coding agents
- Select suitable tasks for AI assistance and recognise tasks that require direct human control
- Configure repository-level instructions and useful project context
- Delegate bounded development tasks using clear goals, constraints and acceptance criteria
- Supervise agent actions across files, commands, tests and version control
- Review AI-generated changes for correctness, maintainability, security and architectural fit
- Integrate coding agents into established branching, review and CI workflows
- Measure productivity without relying on misleading measures such as lines of code
Course Outline
The Shift to AI-Native Development
- Evolution from autocomplete and chat to tool-using coding agents
- How agents inspect code, plan work, edit files and execute commands
- Capabilities, limitations and common failure modes
- Probabilistic agent behaviour within deterministic engineering systems
- Appropriate uses across planning, implementation, testing and maintenance
- Establishing realistic expectations for individuals and teams
Setting Up a Controlled Agent Workspace
- Choosing local, IDE-based and remote agent environments
- Repository access, command permissions and execution boundaries
- Protecting secrets, credentials and sensitive source material
- Using isolated branches, worktrees and disposable environments
- Configuring project instructions and coding conventions
- Recording agent actions for review and accountability
Giving Agents Effective Context
- Identifying the minimum context needed for a task
- Repository maps, architecture notes and authoritative documentation
- Referencing files, symbols, tests and examples precisely
- Separating goals, constraints, evidence and expected outputs
- Recognising stale, conflicting or excessive context
- Maintaining shared instructions without creating instruction clutter
Delegating Development Tasks
- Breaking features and defects into bounded units of work
- Writing task briefs with scope, non-goals and acceptance criteria
- Asking an agent to investigate before it changes code
- Choosing between interactive collaboration and autonomous execution
- Using checkpoints for decisions with architectural or business impact
- Recovering when an agent follows an unproductive approach
AI-Assisted Implementation and Refactoring
- Generating small changes that follow existing patterns
- Implementing features across multiple files and layers
- Refactoring while preserving externally observable behaviour
- Working safely with dependencies and generated configuration
- Using agents to explain unfamiliar and legacy code
- Avoiding unnecessary abstractions and codebase cognitive debt
Testing, Debugging and Documentation
- Asking agents to reproduce and diagnose defects systematically
- Generating tests from behaviour and acceptance criteria
- Checking whether tests genuinely validate the implementation
- Using static analysis, type checking and test runners as feedback sensors
- Producing useful technical documentation and change summaries
- Distinguishing evidence from confident but unsupported explanation
Reviewing Agent-Generated Changes
- Reviewing diffs rather than accepting completed tasks at face value
- Checking correctness, edge cases, security and data handling
- Detecting invented APIs, weak error handling and hidden scope expansion
- Requiring evidence from tests, logs and reproducible commands
- Keeping pull requests small enough for meaningful human review
- Deciding when to revise, revert or restart an agent task
Team Workflows and Adoption
- Integrating agents with issues, branches, pull requests and CI/CD
- Defining approved tools, models and data-handling policies
- Sharing effective repository instructions and task patterns
- Supporting developers with different levels of AI experience
- Measuring lead time, rework, quality and developer understanding
- Creating a practical adoption plan for an engineering team
Practical Capstone
- Select and scope a realistic change in an unfamiliar repository
- Prepare context, constraints and acceptance criteria
- Delegate investigation, implementation and test execution to an agent
- Review the resulting diff and supporting evidence
- Correct weaknesses through targeted feedback or direct engineering
- Present the workflow, controls and lessons learned
Intended audience
This course is designed for software developers, technical leads, test engineers and engineering managers who want a current, practical foundation in AI-assisted software delivery. It is suitable for teams beginning to adopt coding agents as well as developers who already use AI chat or completion tools but want a more disciplined workflow.
Prerequisites
Those attending this course should meet the following:
- Working knowledge of at least one programming language
- Familiarity with Git and pull-request workflows
- Basic understanding of software testing and code review
- Confidence using an IDE or command-line development environment