ALD Skills Model & Ladder
In Architect-Led Development (ALD), effective use of AI is less about “prompt tricks” and more about strong fundamentals: decision framing, contract design, role-based interfaces, DTO modeling, and test-defined behavior.
ALD principle: AI amplifies intent. ALD ensures the intent is correct, explicit, and enforceable.
Promotion in ALD is about increasing ownership of intent and risk—not writing more code.
Core skills for using AI effectively (ALD view)
ALD assumes AI is best used as an implementation engine. Humans must supply architecture, intent, and constraints. These skills make AI safe and high-leverage.
1) Architectural thinking & decision framing
- Identify decision boundaries (policy vs orchestration vs integration)
- Separate business rules from implementation details
- Design stable contracts that outlive technologies
- Think in capabilities and responsibilities (not layers)
2) Role-based interface design (SRP & ISP mastery)
- Apply SRP at the interface level
- Use ISP to avoid “kitchen sink” buckets
- Design small, intention-revealing roles
- Avoid generic CRUD repositories as default abstractions
3) DTO & domain modeling (ubiquitous language)
- Translate business language into types (e.g.,
Money,ReasonCode) - Enforce invariants (invalid states are hard to represent)
- Separate domain DTOs from integration DTOs
- Prefer additive evolution with boundary translation
4) Contract-first & TDD (behavior definition)
- Write contract tests that define policy and behavior
- Distinguish contract tests (governance) from unit tests (implementation)
- Treat contract-test changes as policy changes
- Include negative and edge cases explicitly
5) Patterns literacy (SOLID + GoF, used intentionally)
- Strategy for variability (policies)
- Adapter for integrations (boundaries)
- Decorator for cross-cutting concerns
- Orchestrator for workflow coordination
6) Boundary & integration discipline (Ports & Adapters)
- Design ports as stable domain contracts
- Isolate vendors/frameworks in adapters
- Prevent SDK types from leaking into core logic
- Plan for replaceability and failure modes
7) Governance & change impact awareness
- Classify changes: contract vs implementation
- Plan migrations and manage blast radius
- Encode audit evidence in outputs (reason codes, decision metadata)
- Think in terms of risk and evidence, not just outcomes
8) Prompting as specification
- Write structured prompts with constraints and output formats
- Ask for deltas (Changed + New), not rewrites
- Review AI output against contracts, not intuition
- Use AI to generate drafts—humans own intent
ALD skills ladder
This ladder is capability-based (not title-dependent). The higher you go, the more you own decisions, intent, and risk—and the less you write day-to-day implementation code.
Primary value: produces correct implementations behind defined contracts.
- Implements from existing interfaces/DTOs
- Writes unit tests for implementation correctness
- Uses AI for boilerplate and routine logic
- Follows established patterns and conventions
Promotion signal: consistent delivery with low regression rate; asks clarifying questions instead of guessing.
Primary value: evolves implementations safely and understands contract intent.
- Understands role-based interfaces and DTO meaning
- Recognizes SRP/ISP violations and design smells
- Refactors safely under tests
- Assists with contract tests; strong test discipline
Promotion signal: identifies boundary issues early; suggests contract-safe improvements.
Primary value: shapes contracts and behavior with minimal risk.
- Designs small, role-based interfaces (SRP/ISP intentional)
- Models DTOs using ubiquitous language and invariants
- Writes contract tests that define business behavior
- Understands ports/adapters and clean boundaries
Promotion signal: contract changes are minimal and well-justified; tests read like business rules.
Primary value: owns decisions, risk boundaries, and system intent.
- Defines decision boundaries and long-lived contracts
- Translates policy into contracts + tests (governance)
- Separates policy, orchestration, and integration cleanly
- Establishes architectural guardrails; reviews contracts, not implementations
Promotion signal: teams move faster without increasing risk; fewer incidents; architecture scales across teams.
Primary value: aligns delivery with organizational strategy and risk posture.
- Defines ALD standards and governance models
- Aligns ALD with frameworks (ITIL, NIST, SAFe, regulations)
- Establishes change classification and review models
- Enables AI safely at scale; defines allowed vs restricted usage
Success signal: organization scales delivery and AI use safely; architecture reduces friction instead of creating it.
Promotion in ALD is about increasing ownership of intent—not writing more code.
- Higher levels own “what must be true” (policy + guardrails)
- Implementation becomes increasingly delegated (teams/AI)
- Success is measured in speed, safety, and clarity at scale
Summary matrix
A quick view of how responsibility shifts as ALD maturity increases.
| Level | Focus | Decisions | Contracts | AI role |
|---|---|---|---|---|
| L1 | Implementation | ✗ | ✗ | Boilerplate writer |
| L2 | Behavior | ✗ | ✗ | Implementation partner |
| L3 | Contracts | △ | △ | Draft engine |
| L4 | Architecture | ✓ | ✓ | Workforce |
| L5 | Strategy | ✓ | ✓ | Scale multiplier |