Overview
Engineering best practices remain fundamental to creating great software. Yet AI tools like GitHub Copilot, ChatGPT and Claude have changed how we develop. The question isn't whether to use AI in development - it's how to use it effectively whilst maintaining the engineering discipline that separates good code from technical debt.
This intensive two-day workshop provides developers with the mindset and toolsets needed to write clean, maintainable code that delivers lasting value. Throughout the course, AI tools are encouraged and integrated into exercises, demonstrating how best practice techniques for high-quality code dovetail with best practices for LLM tooling.
By the end of this workshop, delegates will have a much better understanding of why clean code matters and of the techniques for creating better, cleaner, more robust code. Crucially, you'll learn when AI assistance enhances your work and when human judgement remains essential. We aim to move delegates away from thinking and struggling at the implementation level and give them a toolset of best practice thinking and techniques so that they code better - with or without AI assistance.
This workshop can be tailored for beginner and advanced developers alike. We adjust the complexity of the exercises for more experienced attendees and allow additional time for in-depth discussions.
Outline
Foundations of modern software development
- Evolution of software engineering in the AI era
- Understanding why predictions in software development often fail
- Critical thinking when working with AI-generated code
- Tools and frameworks for better decision-making
- Moving from syntax-level thinking to architectural perspectives
- When AI tools help and when they hinder
Clean code principles
- Writing good code through simplicity and readability
- Creating intention-revealing names
- Effective code organisation and decomposition
- API design using contracts and outside-in approaches
- Using standard data structures to solve common problems
- Information hiding and encapsulation strategies
AI-augmented development workflows
- Using GitHub Copilot and AI coding assistants effectively
- Prompting AI tools for better code suggestions
- When to accept, modify or reject AI-generated code
- Maintaining code ownership whilst using AI
- Critical evaluation of AI-suggested implementations
- Building reflexes for quality assessment
Design principles and patterns
- The classic SOLID principles and their relevance today
- Modern design guidelines including CUPID, GRASP, KISS and YAGNI
- Balancing simplicity with performance
- Managing coupling and cohesion in software components
- Composition vs inheritance strategies
- Immutability benefits and implementation approaches
Test-driven development with AI tools
- The importance of testing and TDD workflows
- Testing techniques: black/white/grey box approaches
- Effective test doubles: stubs, mocks, fakes and spies
- Dependency injection for better test isolation
- Using AI to generate test cases and test data
- Verifying AI-generated tests for completeness
Refactoring and code improvement
- Refactoring principles and practices
- Recognising and addressing common code smells
- IDE-assisted refactoring to improve productivity
- Using AI tools for refactoring suggestions
- Validating refactorings with comprehensive tests
- When to trust automated refactoring and when to be cautious
Modern development workflows
- Continuous Integration and Delivery practices
- Version control best practices using Git
- Effective code reviews in an AI-assisted world
- Reviewing AI-generated code contributions
- Pull request best practices
- Productivity enhancement through modern IDEs
- Keyboard shortcuts and powerful extensions
AI tools in professional development
- Comparing capabilities of major AI coding assistants
- Choosing the right tool for specific tasks
- Privacy and security considerations
- Organisational policies for AI tool usage
- Cost considerations and resource management
- Future-proofing your development approach
Sustainable software engineering
- Technical debt management with AI tools
- Building maintainable systems through good design
- Documentation practices in an AI era
- Growing junior developers alongside AI tools
- Mentorship and skill development paths
- Ethical considerations in AI-assisted development
Critical thinking and Quality Assurance
- Assessing quality of AI-generated code
- Identifying subtle bugs in AI suggestions
- Maintaining domain expertise whilst using AI
- Building intuition for code quality
- The human judgement that remains essential
- Continuous learning strategies
Practical integration
- Incorporating AI into daily development workflows
- Building personal prompt libraries
- Sharing effective patterns with teams
- Measuring and improving AI assistance quality
- When to persist with AI and when to code manually
- Balancing speed with quality
Requirements
The course can be tailored to any modern programming language (Java, C#, JavaScript/TypeScript, Python, etc.), but delegates should come armed with a good understanding of the language used. Additional training in language fundamentals can be requested on enquiry.
This is an intensive 2-day workshop that consists primarily of hands-on coding exercises rather than slides. Through live coding sessions with the instructor, delegates will immediately apply the concepts they learn, cementing their understanding through practical experience.
AI coding tools like GitHub Copilot are encouraged throughout the course. Access to these tools enhances the learning experience, though it is not strictly required. Participants should bring laptops with their preferred development environment configured.
No prior experience with AI coding assistants is required - the course will teach effective usage patterns whilst building engineering fundamentals. However, having experimented with tools like Copilot or ChatGPT for coding will enable participants to get more value from the AI-specific content.