AAA Cycle: Align-Agree-Apply
Overview
AAA is a guiding discipline and principle for software development: a way of thinking that provides guardrails against the most common mistakes organizations and development teams make. It is a philosophy that transcends any specific methodology, operating from the software architect’s perspective on what truly matters.
AAA as a Way of Valuing
AAA is about how we value before how we work.
Align
We establish and value human connection. Before we talk about solutions, timelines, or technology, we connect with people. Alignment is not about extracting requirements; it's about building understanding and trust.
Agree
We value shared commitment on how we will accomplish what we're aligned on. Agreement isn't just documentation or sign-offs; it's mutual understanding and genuine commitment to walk the path together.
Apply
We value delivering on agreements. Notice that "deliver" is not the focus; applying the agreement is. We honor the commitments made to the people we aligned with.
Why This Order Matters
Nearly every failed project makes the same mistake: it starts with solutions, jumps to plans, and treats delivery as the goal. AAA deliberately reverses this:
- The need comes first: We align with people and their actual problems before proposing solutions
- Human agreement comes first: We secure genuine commitment before implementation begins
- Applying the agreement comes first: We honor what was agreed before declaring success
When you walk into that first stakeholder meeting, you don't need a project plan. You need to connect with people, understand their world, and establish the foundation for meaningful agreement.
Not a Checklist, But a Discipline
Yes, AAA will present specific details of how an architect ought to communicate and work. You’ll find concrete activities, deliverables, and decision points. But these are examples of the discipline in practice, not rigid steps to follow. AAA is about developing the instinct to:
- Value human understanding before technical design
- Seek genuine agreement before claiming alignment
- Honor commitments before chasing new requirements
- Maintain connection throughout delivery
This discipline applies whether you’re using Scrum sprints, Kanban flows, or waterfall phases. It transcends methodology because it addresses something deeper: how architects think about and engage with the work itself.
Why AAA Matters
The Failures AAA Prevents
Most project failures stem from broken values, not broken processes:
Common Failure Patterns
- Starting with solutions instead of connection: Architects propose technical designs before understanding the human context. Teams build the "right" solution to the wrong problem.
- Confusing documentation with agreement: Sign-offs are collected but genuine commitment is missing. Plans look good on paper but collapse when reality hits.
- Treating delivery as the goal: Teams chase feature completion over honoring commitments. Success is measured by shipped code, not realized value.
The AAA Perspective
What AAA Provides
AAA provides guardrails by keeping these values front and center:
- Connection before solutions: Understand people and their context before designing systems
- Genuine agreement before execution: Secure real commitment, not just sign-offs
- Honoring commitments before chasing features: Apply what was agreed, maintain alignment throughout
- Human needs throughout: Technical decisions remain anchored in the people they serve
Trust Over Politics
Strict frameworks like Scrum often function as defensive mechanisms: ways to protect yourself from stakeholders and vice versa. They create systems of politics rather than trust. Yes, these frameworks are based on truth and provide valuable starting points for organizing teams. But they can become rigid checklists that substitute for genuine human connection.
When Structure Becomes a Shield
The problem isn't having structure; it's when that structure becomes a shield instead of a bridge. When "following the process" matters more than solving the problem. When ceremonies become rituals emptied of meaning.
AAA calls us back to something more fundamental: focusing on what we value. Not “Agile” the branded methodology with capital-A ceremonies, but “agile” the principle of being responsive to reality. Not defensive processes that protect territories, but disciplines that build trust.
Yes, use frameworks. Use their ceremonies and practices. But stay open to discovery and change within each event, each schedule, each unique situation. The framework serves the values (connection, commitment, and honored agreements), not the other way around. When a framework ceremony stops serving those values, you adapt it. That’s the discipline AAA represents: being flexible about how while remaining unwavering about what matters.
The Three Phases
Phase 1: Align with the Need
Establish human connection and deeply understand the context before proposing solutions.
The Core Value: Connection with people comes first. Alignment is not requirement extraction; it’s building shared understanding with the humans behind the need.
What Alignment Produces: A foundation of mutual understanding with stakeholder commitment, not just signatures but real buy-in from people who feel heard.
When you truly align with people and their needs, you avoid building elegant solutions to misunderstood problems.
Phase 2: Agree to the Plan
Secure genuine commitment to how you will accomplish what you’re now aligned on.
The Core Value: Shared commitment to the path forward. Agreement isn’t about getting approval for your design; it’s about creating a plan together and building mutual confidence in the approach.
What Agreement Produces: Authentic commitment from stakeholders and teams. Everyone understands and believes in the path forward because they helped shape it.
When people genuinely agree (versus grudgingly sign-off), they stay committed when challenges arise.
Phase 3: Apply the Agreement
Honor the commitments made and maintain connection throughout delivery.
The Core Value: Delivering on agreements, not just shipping features. Application is about executing what was agreed, in the way it was agreed, while maintaining the alignment you established. When reality requires changes, you return to align and agree again.
What Application Produces: Working software that meets the needs you aligned on, built the way you agreed, delivered by maintaining human connection throughout.
When you honor agreements instead of chasing features, scope stays stable. Value is realized because the right things were built.
Visual Journey
┌─────────────────────────────────────┐
│ FEEDBACK LOOPS │
│ Discovery triggers realignment │
└─────────────────────────────────────┘
│
┌──────────────────────────────┼──────────────────────────────┐
│ │ │
▼ ▼ │
╔═══════════════╗ ╔═══════════════╗ ╔═══════════════╗
║ ALIGN ║ ║ AGREE ║ ║ APPLY ║
║───────────────║ ║───────────────║ ║───────────────║
║ Human ║ ───► ║ Shared ║ ───► ║ Honored ║
║ Connection ║ ║ Commitment ║ ║ Agreement ║
╚═══════════════╝ ╚═══════════════╝ ╚═══════════════╝
│ │ │
▼ ▼ ▼
✓ CONNECTED ✓ COMMITTED ✓ VALUE REALIZED
│ │ │
└──────────────────────────────┴──────────────────────────────┘
│
Cycle repeats at every level
The Flow of Values: Each phase builds on the previous one. You can’t genuinely agree without first aligning. You can’t honor agreements that were never truly made.
When to Revisit: Return to earlier phases when reality demands it. If new information breaks alignment, go back and re-align. If the plan proves infeasible, go back and re-agree. This isn’t failure; it’s the discipline of maintaining integrity.
AAA as a Recursive Cycle
AAA is not just a one-time project framework; it’s a cycle that repeats at every level of work:
| Level | Timeframe | Align | Agree | Apply |
|---|---|---|---|---|
| Program | 6-18 months | Strategic goals, portfolio priorities | Architecture standards, governance | Multiple projects with continuous oversight |
| Project | 3-6 months | Project scope, business objectives | Technical approach, implementation plan | Iterative delivery cycles |
| Sprint | 1-4 weeks | Sprint goals, acceptance criteria | Task breakdown, technical approach | Daily development and testing |
| Feature | 1-5 days | User need, acceptance criteria | Implementation approach | Coding, testing, review |
The same principles apply regardless of scale. Whether you’re leading a multi-year transformation or designing a single feature, you always Align on the need, Agree on the approach, and Apply with discipline.
The nesting principle: Each level of AAA operates within the agreements of the level above. Sprint-level agreements must honor project-level agreements. When a lower level discovers something that breaks a higher-level agreement, you cycle back up to realign and re-agree at the appropriate level.
AAA at the Technical Level
The AAA discipline applies when engineers integrate code too. Align means understanding each other’s work and intentions before modifying shared code. Agree means explicit commitments about interfaces, contracts, and integration points. Apply means honoring those agreements in implementation.
CI/CD automates the verification. Tests are agreements encoded as executable specifications. When a build breaks or tests fail, it’s surfacing a broken agreement: merge conflicts from work that was never aligned, integration failures from misunderstood contracts, breaking changes that honored one agreement while violating another.
When CI fails, ask “what agreement broke?” not just “how do I fix this?” This question leads to root causes rather than symptoms.
For detailed CI/CD guidance, see CI/CD: Continuous Integration and Continuous Delivery.
Related Guides
- AAA Scenarios: Real-world situations and how AAA discipline applies
- Shaped Kanban: Flow-based work with disciplined constraints
- Architecture Decision-Making: ADRs and decision frameworks
- Team Organization: Team structures and collaboration patterns
Found this guide helpful? Share it with your team:
Share on LinkedIn