What Sparked This Post
Watching David O’Hara and Bill Curry kick off the October Improving Talks series with “Ship a Feature Faster: AI and the Case for Change” got me nodding, and also wanting to sharpen a few points. In many of my recent talks and posts (some listed below), I’ve been exploring how we can integrate AI into agile work without compromising human conversations or the creative intent behind our systems. This week’s session gave me a springboard to connect those dots (and add a few).
What the Talk Was About
David and Bill framed where AI sits on the hype cycle, what’s compressible in our day-to-day dev work (CRUD, refactors, specific tests), and what isn’t (context, judgment, architecture, real collaboration). They set up the rest of the month to “dogfood” a new feature in Improving’s Engage platform: end-to-end, from UX to tests/code to CI/CD to data/analytics, showing where AI helps and where it still needs human intervention.
Key beats I tracked:
- Compression vs. elevation: AI shortens specific tasks, allowing humans to focus on higher-leverage work.
- Early‑adopter tradeoffs: cost and churn now, advantage later.
- Developer skills shift: more reviewing, more design/architecture thinking, and better prompting/partnering with agents.
- Workflows in flux: Spec-driven, agent-assisted, and tighter feedback loops are transforming how we plan, build, and learn.
Why It Resonated With Me
1) It’s not “text vs. conversation.” It’s a multimodal conversation.
There was a moment about AI “pushing us back to text.” I’d nuance that. In my talk titled “Will AI Take Your Job or Join Your Standup?“, I argued that we should use every channel we have:
- Type it. Dictate it.
- Sketch it on a whiteboard and let the model interpret it.
- Drop a mockup or wireframe and have AI derive user stories, flows, and a clickable prototype.
Some of us “think in pictures,” some in words, many in blends, and some (as Temple Grandin has taught so well) think in particular visual categories. The point isn’t to pick a single mode; it’s to externalize how you think and let AI meet you there. That’s how we keep the spirit of agile’s “conversation” alive while increasing the fidelity of the artifacts those conversations produce. Think of the hidden gap between what’s said and what’s understood.
Practical take: user stories don’t have to be only sentences; they can be user pictures too: comics, storyboards, annotated flows, especially in UX work. (See the comic‑strip technique in See What I Mean.) AI can now translate those visuals into structured requirements, acceptance criteria, and even runnable scaffolds.
2) Pairing with AI works best with guardrails—and it’s a teaching tool.
I loved the back‑and‑forth on having AI write tests while a human writes the code (and vice versa). In my BDD + AI pair‑programming workflow and in Coaching from the IDE, I show how to:
- Codify house rules (standards, naming, test style, CQRS boundaries) as docs the agent reads before touching code.
- Review, then refine: treat the agent like a junior dev—ask it to explain its plan, run locally, adjust, and update the docs.
- Level up juniors by pairing on reviews, not only on implementation. They learn what “clean” looks like and why.
Result: higher quality and a repeatable learning loop. The agent accelerates the boring parts; the humans own the reasoning, domain language, and design.
3) Collapsing tasks isn’t only about “doing more.” It’s also about doing better.
Yes, AI frees capacity. But the win isn’t merely more throughput; it’s more craft:
- Use the reclaimed time for more profound discovery, richer error states, and thoughtful edge cases.
- Keep cycle times tight, but invest the same sprint in a better experience. The backlog will refill either way; let’s improve what ships.
4) Evidence from the trenches: teams shrink, learning expands.
I’ve documented evidence by capturing a team’s scrum board before and after AI adoption. This is an example of a sprint with a 6-person team before AI:
Here’s the board after the team went down to two people, but starting to leverage AI more effectively:
And here’s the board on the following sprint:
AI took on scaffolding and well-defined and documented implementation patterns; humans split work into two streams:
- Exploration: quick prototypes to validate ideas with stakeholders in Sprint Review.
- Execution: planned, test‑first implementation of validated features, often seeded by those prototypes.
It maintained velocity and improved signal quality. Stakeholders saw more options sooner; the team built the right thing faster.
What I’m Still Thinking About
Multimodal requirements as first‑class citizens
What would a truly mixed‑media backlog look like? Imagine each story can contain:
- A storyboard or comic that conveys the narrative.
- A few key screenshots or a hand‑drawn wireframe.
- A concise “In order to… / I want… / So that…” story.
- Auto‑generated Given/When/Then scenarios derived from the visuals.
- Links to a living “decision log” the agent updates from design and code reviews.
The agile/spec tension: solved by rhythm, not dogma
Strongly‑typed specs help AI, while people need conversations. We can do both by adopting a rhythm:
- Talk & sketch (humans align on intent).
- Render & structure (AI turns artifacts into stories, examples, and a plan).
- Implement in loops (AI proposes, humans review, tests lead).
- Explain & remember (agent updates docs and rationales).
Skill paths for devs in the agent era
- Context shapers: turn stakeholder signals (notes, transcripts, diagrams) into precise prompts/specs.
- Architecture reviewers: steer tradeoffs, enforce boundaries, and keep coherence.
- Experience editors: use reclaimed time to refine flows and copy, not just code.
Concrete Ways I’ll Keep Building on This Series
- User Pictures over User Stories (where it helps)
For discovery‑heavy items, start with a storyboard + single‑sentence purpose. Let AI derive scenarios and a skeleton prototype; review with stakeholders in the same sprint. - Two‑lane boards
Keep a visible split between Prototype/Discovery and Implement/Hardening. Celebrate learning completed, not just points burned. - Guardrailed pairing
- Maintain a repo‑local “Standards & Test Style” doc the agent must read.
- Require an agent plan before any multi‑file change.
- Treat agent output like a junior PR: ask for rationale, request changes, and have it update the docs.
- Teach with AI
Use the agent to propose reviews, identify smells, and generate “before/after” refactors juniors can learn from. - Quality over quantity
When compression shows up, spend the delta on UX clarity, resilience, and edge‑case coverage.
Want to Watch It?
Check out Bill and David’s Ship a Feature Faster: AI and the Case for Change recording here.
Leave a Reply