Macmillan Learning
By late 2025, Macmillan Learning had 15 different AI implementations live across four Macmillan products, built up over roughly two years as teams shipped AI features on their own timelines. The Macmillan Director of UX Design brought Openfield in to take stock of what had accumulated and build a shared foundation. I led the design work, with another UX Designer from Openfield iterating alongside me on components, and a Product Design Engineer consulting on how those components would need to be built once they left Figma.
The first phase of the Macmillan AI Standardization project covered three AI use case verticals (AI Chat Interfaces, Content Creation, and Grouping & Summarization), though only the first two made it through to a finished, documented system in this phase. This case study covers that work: the audit, the standardization of AI Chat Interfaces and Content Creation, and what got shelved along the way.
Fifteen AI implementations across four Macmillan products meant fifteen different ideas of what an AI chat input, send button, or "thinking" state should look like. Each one solved a problem for its own use case, but none of them worked quite the same way.
These similar, but different patterns can increase the cognitive load across a product. While mismatching patterns in isolation can seem small or inconsequential, they can add up as a user moves through the system as a whole, leading to uncertainty if one tool can or should function the same as another they just encountered on a different page.
My UX Design partner and I gathered screenshots from every implementation we could find, with help from the product team to make sure we weren't missing anything. Laid out next to each other, the fragmentation was obvious in a way it hadn't been when each tool was judged on its own.
From there, the approach was the same for both use cases we completed: benchmark against how other products in the space handle the same interaction, find the patterns that were common across our own implementations, then build a standardized version as reusable components with the behaviors documented alongside them. Our Product Design Engineer's role was to make sure what we designed could actually be built consistently in Prose, Macmillan's design system, so we looped them in once a component was solid in Figma, before handing it off.
AI Chat Interfaces was the first vertical we tackled, and the biggest. It's also where the inconsistency was most visible: nine or so different chat experiences, each with its own take on the same basic input-response loop.
We broke the interface down using atomic design: starting with the text input itself, then layering in the optional pieces around it (an additional-actions slot, a dictation slot, an attachments slot, and the send button) so that any team building a chat feature could pull only the pieces their use case actually needed, rather than inheriting a monolithic component built for someone else's requirements.
Once the components were defined, we documented how they needed to behave together, since a shared component library doesn't do much good if every team still improvises its own interaction pattern on top of it. We wrote up five core behaviors: text field behavior, sending message behavior, dictation behavior, prompt suggestion behavior, and large chat window display.
How the field grows with longer input, where file attachments and additional actions live, max height before scrolling.
Content Creation came next, and it needed a different lens than AI Chat Interfaces. Instead of standardizing many similar implementations, we had fewer implementations, but they were each doing more specific things, which meant standardization wasn't as clean-cut as it was for chat.
That meant stepping back further before designing anything. We documented the user flow for each individual implementation, then benchmarked other AI content tools outside Macmillan to build a comparison set. Cross-referencing our own flows against what we found through benchmarking, we found the through line: every implementation, despite looking different on the surface, was really some version of the same three-step process: Input, Refinement, Output. That gave us a foundation to standardize against, both the larger flow and the individual components needed to support it, instead of just picking one implementation and calling it the standard.
The finished components and behaviors covered the full content creation flow: content creation from scratch, content creation for pre-existing content, preset refinement options, text input refinement, and retry behavior.
A blank page, a prompt, a generated draft with Retry and Insert options, and the formatted content landing correctly once inserted.
Some of what we built for AI Chat Interfaces carried over directly. The chat input field, for example, didn't need to be reinvented for Content Creation, which was a good early sign that the atomic approach was actually paying off rather than just being a nice idea on paper.
It also made a case for atomic design bigger than either vertical on its own: the same small pieces holding up across two different use cases meant the approach wasn't just tidy in theory, it actually adapted to whatever a team needed from it.
We started Grouping & Summarization using the same process and got partway through the design work before it was deprioritized in favor of other feature commitments. It's not part of this case study's finished system, but the groundwork is there for whenever it gets picked back up.
Macmillan AI Standardization is recent enough that I don't have adoption numbers to point to yet: that's something that would need to be tracked over time, and we haven't had the runway for it. What I can say is that the design team has started adopting the patterns we defined on new work, which is the outcome I was actually looking for at this stage: not a mandate to rip out and rebuild everything at once, but a shared reference that makes the next AI feature easier to build consistently than the last one was. Every time a team builds on top of what we defined instead of improvising their own version, that's one fewer inconsistency a student or instructor has to relearn their way through.
Macmillan's product roadmap couldn't pause for a wholesale redesign, so instead of a single cutover, teams update toward the new patterns as they revisit the tools over time. It's slower than I'd like in the abstract, but it's the realistic version of how a system like this actually takes hold inside a live product.
Atomic design paid off almost immediately.
Watching the chat input field carry over cleanly from AI Chat Interfaces into Content Creation was proof that building small, reusable pieces instead of one-off screens was the right call, and that those pieces could flex to cover very different use cases.
Not everything needs to ship to be worth doing.
Grouping & Summarization got deprioritized before we finished it, but laying the groundwork for this initiative is a step in the right direction in Macmillan's overall AI strategy.