Turning Conversations into Context

A framework for teams building with AI. Not just individuals.

AI exposes your real constraints. D3 helps you address them through better collaboration, not tooling. Built from real engagements by practitioners at Equal Experts.

Get in Touch Read Our Blog

Counterintuitive Findings

What surprises teams about AI-enabled delivery

These findings often catch teams off guard when they start working with AI tools.

AI-enabled delivery is about collaboration, not tools

Everyone has access to the same AI tools. The difference is how teams collaborate and create context for those tools to use. The tooling matters less than the conversations that feed it.

AI exposes your real constraints

Writing code was never the bottleneck. When AI can generate code in minutes, the real constraints become obvious. Architecturally: tight coupling, shared infrastructure, slow builds, testing bottlenecks. Organisationally: unclear requirements, delayed decisions, stakeholder unavailability. AI accelerates development so much that you'll hit these constraints in days instead of weeks.

AI raises the bar for engineering skills

AI doesn't replace thinking about systems. It raises the bar—you need to understand what good design looks like to review AI-generated code effectively. System design, architectural judgment, and code review skills become more important, not less.

What Doesn't Work

Mistakes we've seen (and made)

Learning from what went wrong across different teams and projects.

Uncoordinated tool rollouts

Deploying 1,200 licences without support, training, or structured adoption. Teams get tools but not practices. Six months later, usage is at 20% and nobody knows why.

Siloed AI experiments

Innovation teams exploring AI in labs, but findings never reach the teams shipping software. Double work across business units, no sharing back. Each team inventing their own approach.

Platform-centric approaches that create lock-in

Big consultancies pushing proprietary platforms. You adopt their tooling, then can't leave. The capability lives in their platform, not your team.

Hiding collaboration in Git

Don't make stakeholders collaborate in markdown files hidden in Git repositories. Product managers and designers shouldn't need to learn Git workflows to contribute to specifications.

Generating too much documentation

Since it's easy to generate information, people and tools tend to create loads of artifacts. This increases cognitive load and makes it harder to maintain review discipline.

Constantly iterating on workflows instead of delivering

More time tweaking workflows than shipping. Pick an approach, deliver, learn, adjust. Delivery creates feedback.

Dialog Driven Delivery

Built from real engagements, not theory

Developed with Equal Experts from real client engagements. D3 packages what we learned into a repeatable approach.

The principles

Cross-functional dialog is the source.

Product, engineering, and design thinking together is the default, not optional. These conversations produce context that isolated documentation never can. AI makes capturing and structuring this dialog practical for the first time.

Context engineering is the core skill.

AI follows context. The richer and more structured that context, the better the output. Building it—capturing dialog, structuring specifications, curating decisions—is the work that determines whether AI tools help or hinder.

Human accountability is non-negotiable.

AI drafts. Humans review. Every specification, every story, every decision passes through human judgment. Speed without review is just faster mistakes. We use AI to accelerate, not to bypass the people accountable for outcomes.

The approach

Cross-functional by design

Built for collaboration, not bolted on

Agnostic about models

Not tied to a specific AI vendor or model

Software is a product of teams

Teams deliver software, not individuals with AI

Enterprise-ready

Works with existing tools, legacy systems, compliance requirements

Feature-based specs

Document where knowledge compounds, not at task level

Uncertainty is explicit

Mark assumptions and open questions to prevent AI invention

The workflow

Capture

Start with a cross-functional conversation. Product, engineering, design—together. Capture the dialog where shared understanding forms.

Refine

Context comes from everywhere. Dialog, designs, prototypes, technical decisions, user feedback. Specifications evolve through whatever inputs emerge.

Decompose

Turn shared understanding into deliverable work. Break features into stories that stay connected to their source context.

Implement

Context flows to code. Findings flow back to specifications. The bridge between conversation and implementation stays current.

Our implementation baseline

This is our baseline implementation. The commands and workflow are what we use. The tooling is adaptable—built on Claude Code with Atlassian Jira and Confluence, but migrates to other tools.

d3/create-spec

Takes a conversation transcript and generates a feature specification. Captures context, decisions, constraints, and open questions from the dialog.

d3/refine-spec

Evolves the specification as new context emerges. Add designs, technical decisions, user feedback—specifications stay living documents.

d3/decompose

Breaks features into smaller deployable pieces with clear acceptance criteria. Each piece stays connected to its source specification.

We provide starter templates for specifications and stories. The templates encode the patterns we've found useful. Adapt them to your team's needs as you learn.

Outcomes

What teams achieve with D3

Fewer handovers

Shared understanding is created collaboratively, rather than translated across documents and roles.

Less rework

Uncertainty and disagreement are addressed early, when they're cheap to resolve.

More effective AI use

Clear, structured context improves output quality and builds trust across engineering teams.

Better scalability

Practices that work across federated organisations, not locked inside individual experts.

Tactical Patterns

Other patterns that work well

Practices that consistently help teams beyond the D3 framework.

Design systems that support feedback loops

Architecture, CI/CD, and testing infrastructure should enable AI to iterate and self-correct. Tests, linting, and type systems provide deterministic validation—AI can check its own work and improve before human review. Design for this from the start.

Create an implementation plan before AI codes

Have AI generate an implementation plan first. Review the approach before any code gets written. This catches misunderstandings early—when changing direction is cheap. Execute only after human sign-off on the plan.

Use AI as the first pass in code review

Let AI review code before humans do. AI catches issues, iterates on fixes, and brings cleaner code to human review. Run multiple review flavors in parallel—security review, performance review, style review—each surfacing different concerns. If available, combine different models for review; each has different strengths.

Build team guidelines iteratively

Start with minimal instructions for AI. Add rules and guardrails based on patterns you see in pull requests. If AI keeps making the same mistake, add a guideline. Team context grows from real feedback, not upfront speculation about what might go wrong.

Ready to adopt D3?

Equal Experts helps teams and organisations adopt AI-enabled delivery practices. Whether you're piloting with a single team or rolling out across the organisation, let's talk about what works for your context.