There's no shortage of AI consultants, workflow gurus, and LinkedIn prophets promising that AI will help businesses do the same work in half the time. Some of that is true. Some of it is marketing.

As a product manager, what excites me most isn't automation for automation's sake. It's what the next generation of software products will look like.

The last software shift that felt truly transformative was the launch of Apple's App Store. Suddenly software wasn't something you only used while sitting at a laptop. It lived in your pocket, connected to the internet, cameras, GPS, touchscreens, microphones, and sensors. Entire categories of businesses appeared almost overnight.

AI feels similar.

Not because every application will become a chatbot, but because software is becoming less prescriptive. Applications can now understand context, generate content, interpret documents, and explain complexity. The interface might not ultimately be chat-based—I still think clicks, visual cues, and good UX will win out—but AI is opening doors that simply weren't available to product teams a few years ago.

The challenge is separating genuine customer problems from AI hype.

The three examples below all started the same way:

Find a real customer problem. Then determine whether AI is the right tool.

1. AI Product Description Generation

One of the most reliable things AI can do today is work with language.

My eCommerce platform, CV ecommerce, integrates deeply with ERP systems. Sellers often maintain product information inside their ERP or PIM, which then synchronises into the commerce platform. In reality, those descriptions aren't always suitable for every sales channel.

We noticed something interesting in our analytics.

Customers were spending a significant amount of time manually editing product descriptions and SEO metadata directly within our CMS. The data showed a large volume of users actively typing into our WYSIWYG editors rather than relying on synced ERP content. This aligned perfectly with the problem statement behind the project: writing product descriptions and SEO content was consuming a significant amount of seller time.

This felt like an obvious candidate for AI.

Rather than creating a separate workflow, we embedded the capability directly into the existing editing experience. A "Generate with AI" action was added alongside the existing content fields, allowing sellers to generate:

• Product descriptions
• SEO URLs
• Meta page titles
• Meta descriptions

without leaving the page.

The implementation itself was relatively straightforward. We integrated with OpenAI through a reusable service layer, added configurable prompts, and used existing product information such as titles and descriptions to provide context. Feature flags allowed gradual rollout and usage monitoring while we validated customer adoption.

The first version wasn't perfect.

We quickly discovered that model selection mattered. Some cheaper models produced content that felt generic or outdated, while newer models produced stronger results at higher cost. Finding the right balance between quality, recency, and operational cost became part of the product design process rather than purely a technical decision.

The result was simple but impactful:

A task that previously took several minutes per product could now be completed with a single click.

For sellers managing dozens of products each day, those minutes quickly became hours saved every week.

"Customers that manage their products on web will type out product descriptions and SEO information by hand. This can cost them a lot of time."

Technical Notes

• Integrated OpenAI content generation directly into existing CMS product maintenance screens rather than creating a separate AI workflow.
• Controlled rollout using PostHog feature flags, allowing staged release, experimentation, and adoption tracking.
• Built a reusable AI service layer to standardise model access, prompt management, and future feature development.
• Supported configurable character targets and content constraints to align generated content with channel requirements.
• Included validation, error handling, telemetry, and usage monitoring from day one to support ongoing optimisation and model evaluation.

2. AI-Powered Code Summaries for Custom Widgets

The second feature reused much of the same infrastructure but solved an entirely different problem.

Our platform allows customers and implementation teams to create custom scripts and widgets that execute server-side.

This flexibility is incredibly powerful.

It's also a support nightmare.

Over the years, hundreds of custom scripts accumulated across customer implementations. Many were written by staff who had since moved on. Some contained little documentation. Others had none at all.

When support engineers encountered one of these widgets, they typically did one of two things:

1. Spend time reading through unfamiliar code.
2. Copy and paste the code into ChatGPT and ask what it did.

Neither option was ideal.

The user story was simple:

"As a staff member, I want to be able to easily understand what custom-written code is doing, so that I can more quickly troubleshoot errors and support customer configurations."

Since we already had an AI integration layer in place, we pointed it at this problem.

A new Generate Summary action was added to custom scripts and widgets. When triggered, the platform sends the code to OpenAI along with tailored prompts and generates a concise explanation of the code's purpose and behaviour. The generated explanation is then inserted directly into the existing Notes area.

The most interesting outcome wasn't the summary itself.

It was the behavioural change.

Because summaries were generated into the Notes field, support teams were encouraged to review, improve, and save them. Over time this creates lightweight documentation that benefits the next person who encounters the same customisation.

Instead of repeatedly asking AI to explain the same widget, knowledge begins accumulating inside the product itself.

That makes every future support interaction faster.

Technical Notes

• Reused the existing OpenAI integration and AI service layer originally built for content generation.
• Entire script or widget source is passed to AI using prompts specifically designed for code comprehension and support use cases.
• Generated summaries are written directly into the existing Notes infrastructure, avoiding the need for new storage or UI components.
• Existing notes are preserved and appended to rather than overwritten, maintaining historical knowledge.
• Restricted to internal staff usage to support troubleshooting workflows while managing security, cost, and governance concerns.

3. Automatic Document Mapping in Lucy

The third example is probably the most technically interesting.

Lucy is an automation platform that processes purchase orders and integrates them into ERP systems.

Before a seller can begin processing orders from a new trading partner, Lucy needs to understand the layout of that partner's purchase order documents.

Historically, this required a manual mapping process.

A user would open a PDF, identify fields such as:

• Purchase Order Number
• Product Code
• Quantity
• Unit Price

and manually draw field boundaries on the document.

This works.

But it's tedious.

It's particularly painful for new customers who may need to configure dozens of trading partners during onboarding.

The original problem statement was straightforward:

"Mapping and onboarding can be daunting for new customers, especially when data moves outside existing mapped regions."

Our first instinct was to use Azure Document Intelligence to fully extract purchase order data.

The challenge was cost.

At scale, some customers process hundreds of purchase orders every day. Running expensive document extraction workflows on every document wasn't commercially attractive.

Instead, we looked for a more targeted approach.

The breakthrough was using AI only when Lucy couldn't find an existing document map.

Rather than processing every purchase order, Azure Document Intelligence is invoked only during the document mapping workflow when no suitable map exists. This dramatically reduces processing volume and cost.

The system analyses the PDF, identifies key fields, converts the coordinates into Lucy's mapping system, and generates suggested mappings for review. Users can then accept, adjust, or reject the suggestions.

What I like about this solution is that it combines AI with human validation.

AI handles the repetitive, low-value work.

The user remains in control of the final mapping.

That balance often leads to better product outcomes than chasing full automation.

Technical Notes

• Uses Azure Document Intelligence's prebuilt invoice and document models to identify purchase order fields and document structure with minimal custom training.
• Selected after evaluating custom machine learning approaches and existing map-matching techniques, with Azure providing the fastest path to a production-ready solution.
• Leverages Microsoft's existing field taxonomy, simplifying mapping between extracted fields and Lucy's internal document model.
• Triggered only when no matching document map exists, significantly reducing processing volume and ongoing operational costs.
• The architecture intentionally focuses AI usage on onboarding and exception scenarios rather than every purchase order, improving commercial viability at scale.
• Converts AI-detected field coordinates into Lucy's document mapping system and automatically generates suggested mappings.
• Supports automatic suggestions for Purchase Order Number, Product Code, Quantity, Unit Price, and other commonly mapped purchase order fields.
• Uses a human-in-the-loop workflow where users can review, adjust, accept, or reject generated mappings before activation.
• Controlled through frontend and backend feature flags for staged rollout, testing, performance monitoring, and safe iteration.

What I've Learned So Far

The most successful AI features I've shipped haven't started with AI.

They started with frustration.

Writing product descriptions is frustrating.

Understanding undocumented custom code is frustrating.

Manually mapping documents is frustrating.

AI happened to be a good solution to each of those problems.

The lesson for product teams is simple:

Don't start by asking "Where can we use AI?"

Start by asking:

"Where are customers wasting time?"

Sometimes the answer will involve AI.

Sometimes it won't.

But when the technology genuinely removes friction, the impact can be substantial.

And if the last two years are any indication, we're still only at the beginning of discovering what that next generation of software will look like.