LeSS in Action (Large Product Developers)
131 Killiney Road, Singapore
Singapore
239571
Сингапур
Description :
Organizational Agility is constrained by Technical Agility.
|
The 5-day development practice course is 70% hands-on and 30% lecture and has three main focuses: Large-Scale Scrum, technical practices, and authentic team dynamics. It covers Scrum practices such as cross-team Sprint Planning, Backlog Refinement, working as a team, and many technical practices such as AI-Augmented Development, Test-Driven Development, Continuous Integration, Acceptance Test-Driven Development, and Refactoring. It also covers how to apply these practices in a legacy codebase situation. |
A major theme of the course is the modern product developer capability needed in the age of AI. Participants practice people-centric analysis: understanding users, their emotions, constraints, context, and real needs before jumping into solutions. They also practice the art of problem decomposition: breaking large, ambiguous problems into smaller learning steps while preserving user value, feedback, and system integrity.
The course explores TDD as Jidoka for AI-augmented development. Tests connect human intent, AI-generated code, and fast feedback, allowing developers to use AI productively while retaining judgment, control, and responsibility.
Participants also practice refactoring for token-efficiency. This means improving the quality of knowledge preservation in code, tests, names, and design so both humans and AI need less context, make fewer wrong turns, and solve problems more reliably.
Finally, the course highlights foundations that cannot be outsourced. AI tools create faster feedback than developers have ever experienced before. This can accelerate learning and delivery, but it can also distort attention, judgment, and learning habits. Participants explore the human foundations that remain essential in AI-augmented development: sleep, attention, critical thinking, disciplined learning, empathy, and professional responsibility.
The goal is not only to understand LeSS or use AI tools. The goal is to experience what kind of product developer capability makes large-scale agility possible.
Who is this class for:
We don't expect participants to have prior knowledge of the tech stack listed below, including the programming languages or domain. People are welcome to the class as long as they are fluent software developers.
We also allow 1~2 non-current developers (e.g., a ScrumMaster or PO) in each class, as long as they have some development experience and promise to work as a developer in a team in the class. So far, their feedback is even better than the developers:-) It's probably due to the opportunity to observe a team from within and the others doing their job.
What did people say about my course:
Testimonial from Bastiaan van Hamersveld (CEO of the LeSS Company) https://www.linkedin.com/posts/konstantin-ribel_lessworks-technicalexcellence-tdd-activity-7121106565994024961-0h2K?utm_source=share&utm_medium=member_desktop
From Oleksii Khodakivskyi:
Current Tech Stack:
We chose a particular stack so that people do real work in the class, but the specific stack doesn't matter so much for participation. Our current stack is:
- Cursor with AI models as the main IDE for development
- a web service (https://doughnut.odd-e.com)
- VueJS 3 on the frontend using TypeScript
- Spring Boot backend using Java and MySQL
- various external service dependencies
- Cypress for end-to-end testing
- Github Action for CI/CD
- Google Cloud for production
The source code is here: https://github.com/nerds-odd-e/doughnut
Agenda :
Monday: Understanding people, problems, and the Product Backlog
- People-centric analysis: understanding users, emotions, constraints, context, and needs
- Requirement workshop / Product Backlog Refinement / Acceptance Test-Driven Development
- The art of problem decomposition
- Multiple-team Sprint Planning
Tuesday: TDD, AI, and fast learning loops
- Test-Driven Development
- TDD as Jidoka for AI-augmented development
- AI-augmented software development
- Scope management through feedback and learning
Wednesday: Refactoring, feedback, and knowledge preservation
- Refactoring in the age of Artificial Intelligence
- Refactoring for token-efficiency
- Building fast feedback loops
- Knowledge preservation in software development
Thursday: Design, integration, and large-scale collaboration
- Evaluating software design in the age of Artificial Intelligence
- Definition of Done
- Coordination and integration
- Feature Teams
Friday: Legacy code, adoption, and sustainable developer capability
- Working with legacy code
- Adoption of new practices
- Foundations that cannot be outsourced to other people or AI
- Retrospective
Details :
Welcome to the LeSS in Action training. This course is designed to help you develop the capability needed to thrive in a large-scale product development environment, especially in the age of AI-augmented software development.
Through hands-on practice, real-time coaching, and collaborative learning, you will gain practical experience in both the technical and organizational aspects of Large-Scale Scrum (LeSS). The course is not only about learning practices. It is about experiencing how product developers understand people, decompose problems, create fast feedback, preserve knowledge, collaborate across teams, and use AI without giving up human judgment and responsibility.
People-Centric Analysis
Software development starts with people, not solutions. Product developers need to understand users, stakeholders, their emotions, constraints, context, and real needs before jumping into implementation.
In this course, participants practice people-centric analysis through Product Backlog Refinement, examples, conversations, and real product decisions. The goal is to turn human understanding into concrete development choices, acceptance examples, tests, and design direction.
Product Backlog Refinement Workshop
One of the most critical activities in LeSS is the Product Backlog Refinement (PBR) workshop. By conducting PBR within the Sprint and involving multiple teams, we will cover several essential aspects:
- Understanding users, stakeholders, needs, and constraints
- Splitting large Product Backlog items into smaller, valuable, learnable items
- Detailing items through conversations, examples, and shared understanding
- Estimating effort and uncertainty
- Discovering dependencies and coordination needs across teams
We may also explore optional techniques based on the context and needs of the group, such as impact mapping, story mapping, specification by example, and estimation ceremonies.
The Art of Problem Decomposition
Large-scale product development depends heavily on how problems are decomposed. Poor decomposition creates dependencies, local optimization, handoffs, and weak feedback. Good decomposition preserves user value, creates learning opportunities, and enables teams to move safely in small steps.
In this course, participants practice decomposing large, ambiguous problems into smaller learning steps while preserving user value, feedback, and system integrity. The focus is not merely on splitting work, but on splitting problems in a way that improves understanding, coordination, and adaptability.
Definition of Done
A well-defined Definition of Done (DoD) is crucial to maintaining quality and consistency across teams. In LeSS, the DoD is not merely an agreement; it is also a measurement of organizational capability.
We will explore the purpose of the DoD, how to create and use an effective DoD, how it evolves, and who should be responsible for ensuring it is followed. We will also connect the DoD to integration, quality, technical practices, and organizational improvement.
Sprint Planning
The PBR workshop also covers much of Cross-team Sprint Planning Part One, as there is only one Sprint in the course.
We will then move into Sprint Planning Part Two, where teams plan how to work together, how to create feedback, how to coordinate with other teams, and how to make progress without losing shared understanding.
Acceptance Test-Driven Development with Cucumber and Friends
Driving development with concrete examples derived from the PBR workshop is key to maintaining alignment and quality.
In this segment, we will discuss technical approaches, good practices, and conventions for Acceptance Test-Driven Development (ATDD) using Cucumber and related tools. Participants will practice using examples as a bridge between user understanding, team communication, test automation, and implementation.
Test-Driven Development
Starting from Day 2, all coding will follow the principles of Test-Driven Development. We will briefly introduce the philosophy with simple exercises, but most learning will come from hands-on practice and real-time coaching.
Participants will experience TDD not as a mechanical testing ritual, but as a way to think, learn, design, and move safely in small steps.
TDD as Jidoka for AI-Augmented Development
In AI-augmented software development, TDD becomes even more important.
AI can generate code quickly, but speed without judgment can create confusion, defects, and shallow learning. TDD acts as a Jidoka mechanism that connects human intent, AI-generated code, and fast feedback. It helps developers detect misunderstanding early, stop when something is wrong, and retain control over correctness, design, and learning.
Participants will practice using tests to guide AI tools productively without outsourcing responsibility for the result.
AI-Augmented Development
As AI becomes increasingly integrated into software development, product developers must become better critical thinkers, evaluators, and designers of feedback loops.
In this segment, we will cover:
- Collaborating effectively with AI agent tools to enhance productivity
- Using AI while preserving human judgment and responsibility
- Evaluating AI-generated code and results critically
- Designing feedback loops that make AI-assisted work safer
- Understanding when AI accelerates learning and when it hides misunderstanding
- Redefining what “good code” means when code becomes a co-created product of humans and AI
The course treats AI as a powerful development partner, not as a replacement for product developer capability.
Collaboration Techniques
Effective collaboration is essential in a Large-Scale Scrum environment. We will explore fundamental techniques and practices that enable teams to work together effectively, including:
- Working in teams and fostering collaboration
- Source Control Management and build automation
- Pair programming and collaborative development
- Continuous Integration and CI systems
- Collective code ownership
- Cross-team coordination and integration
The course emphasizes collaboration through real work, not only through discussion.
Code Refactoring
Maintaining a healthy codebase is an ongoing effort. This segment covers why refactoring is essential, what to look for when identifying code smells, and how to improve code without introducing new issues.
Participants will practice refactoring as part of normal development, supported by tests, feedback, and continuous integration.
Refactoring for Token-Efficiency
In the age of AI, refactoring has an additional meaning.
Token-efficiency is not only about the number of literal AI tokens. It is about how much context, attention, searching, reasoning, and retrying a human or AI needs before successfully solving a problem.
Poorly preserved knowledge wastes this limited budget. Developers and AI may chase the wrong path, inspect suspicious but irrelevant parts, misunderstand names, miss hidden coupling, make mistakes, and try again. Good refactoring improves the quality of knowledge preservation in the system.
Participants will explore how better names, smaller concepts, clearer tests, improved cohesion, reduced duplication, and cleaner design help both humans and AI need less context, make fewer wrong turns, and solve problems more reliably.
More on Test Automation
Beyond automated acceptance and unit tests, we will dive deeper into effective testing strategies, including:
- Real and exploratory testing
- Product-wise testing strategies
- Best practices for automated testing
- Unit testing in different programming languages
- Combining automated and human testing for better feedback
- Using tests as preserved knowledge for both people and AI
Building Fast Feedback Loops
Fast feedback is central to both LeSS and technical agility. Participants will experience feedback from tests, CI, code review, pair work, team interaction, Product Owner conversations, real users, and AI tools.
We will explore how to design feedback loops that are fast, trustworthy, and meaningful. The goal is not simply to get feedback quickly, but to create feedback that improves decisions and learning.
Knowledge Preservation in Software Development
Software development is a knowledge-intensive activity. Valuable knowledge should not live only in people’s memory, chat history, or temporary AI conversations.
We will explore how knowledge is preserved in code, tests, names, examples, design, documentation, automation, and team habits. This connects directly to refactoring, TDD, ATDD, CI, and AI-augmented development.
A key theme is: outsource preserved knowledge into the system, but keep thinking, judgment, and learning inside the people.
Thinking About Design
Design is not a one-time activity, but an ongoing process. We will discuss the difference between emergent design and traditional waterfall-style design, and introduce modern design principles and paradigms.
In the age of AI, software design must also be evaluated by how well it supports human and AI comprehension, safe change, fast feedback, and knowledge preservation.
We will revisit real testing and refactoring to ensure our design decisions support effective quality assurance and future adaptability.
Feature Teams
With the knowledge gained from the first four days, we will revisit the concept of Feature Teams to understand how technical practices align with organizational structures.
Feature Teams are not only an organizational design idea. They depend on technical practices, shared ownership, learning capability, and the ability to work across the whole product. We will explore how to maximize the potential of self-sufficient teams in a large-scale product development environment.
Working with Legacy Code
Inspired by Michael Feathers’ Working Effectively with Legacy Code, this segment covers practical strategies for dealing with untested and outdated codebases.
Participants will learn how to build confidence when making changes, introduce tests safely, identify seams, improve design incrementally, and use AI carefully in legacy-code situations.
Foundations That Cannot Be Outsourced
AI tools create faster feedback than developers have ever experienced before. This can accelerate learning and delivery, but it can also distort attention, judgment, and learning habits.
The rapid cycle of prompt, response, apparent progress, and more prompting can create a dopamine-driven feedback loop. Developers may feel productive while avoiding slower but essential activities such as careful reading, debugging, deep thinking, and real learning.
In this segment, we explore the human foundations that cannot be outsourced to other people or AI, including:
- Sleep and physical energy
- Attention and sustained focus
- Critical thinking and judgment
- Learning discipline
- Empathy for users and teammates
- Professional responsibility for outcomes
AI makes these foundations more important, not less.
Craftsmanship
We will discuss software craftsmanship as an alternative metaphor for career progression in software development. This perspective emphasizes continuous learning, skill enhancement, care for quality, and responsibility for the work.
In the age of AI, craftsmanship does not disappear. It changes. Product developers need to learn how to combine human judgment, technical skill, AI assistance, and disciplined feedback loops to create valuable and maintainable software.
Retrospectives
To conclude the training, we will conduct a retrospective to reflect on the journey and lessons learned.
Participants will experience a well-structured retrospective, discuss common pitfalls, and explore how to facilitate effective retrospectives in large organizations. We will also connect retrospectives to adoption of new practices, continuous improvement, and organizational learning.
Emergent and Context-Sensitive Learning
No two trainings are the same. The dynamic nature of the course means that many sessions will be shaped by the challenges faced by the participants.
Through adaptive learning and practical problem-solving, participants will gain experience in real-world, large-scale product development environments. The course content emerges from the interaction between the planned topics, the real product work, the participants’ questions, and the problems encountered during the week.
We look forward to working with you and embarking on this journey together.
Price: 3 000 SGD