NOTE: Demo visuals include blurred data or synthetic placeholders to protect customer privacy.
About Code to Feature Pages
Brandon introduces the problem through a familiar scenario. A feature is shipped, and a PMM is asked to get it onto the website.
The work begins in GitHub, reading through a pull request to understand what changed. From there, the PMM moves into Jira to gather context and customer-facing implications. Next comes the challenge of determining where the feature belongs on the website and how it should be positioned.
That still is not enough. The process continues through marketing guidelines, CMS formatting, Slack conversations, and often additional meetings to fill in gaps.
What looks like a simple request becomes a chain of dependent steps across systems and teams.
Three frictions consistently slow things down:
- Understanding a feature requires stitching together PRs, Jira tickets, and conversations
- Content creation involves multiple rounds of drafting, review, and alignment
- Website pages fall out of date as product velocity outpaces content production
To quantify this, Brandon asked Nora to analyze the workflow. The result was consistent: it typically takes two to three weeks for a feature to move from merged code to published website content. When broken down, that process represents roughly 432 hours across drafting, approvals, and coordination.
That is the system this work replaces.
How the Pipeline Works
Code to Feature Pages introduces a structured pipeline that connects merged code directly to website updates. Instead of relying on manual interpretation at each step, the system defines a consistent flow from input to output.
It begins by ingesting merged GitHub PRs along with their linked Jira context. From there, the system classifies each change into the correct product area and sub-feature, ensuring that content is generated in the right place.
A readiness check filters out anything that is not customer-facing, such as feature flags or internal testing work. Related changes are then grouped to combine small updates into a coherent customer story.
Once structured, the system generates customer-facing content using LLM reasoning guided by product and marketing context. That content is pushed into the CMS and made ready for publication.
The objective is not partial automation. Brandon’s target is clear: once a PR merges, the website should update within minutes.
How the MVP Works
The demo highlights a key limitation in the current website structure. Inbound email security, one of Abnormal’s core products, is represented on a single page. That page attempts to cover a wide range of functionality, making it difficult to communicate the full depth of the product.
The MVP restructures this model.
Instead of a single page, the site is broken into granular sub-feature pages, each aligned with specific capabilities within the product. These pages are directly tied to the codebase, creating a clear mapping between what is built and where it appears on the site.
In the prototype:
- Product areas expand into sub-features
- Each sub-feature has its own dedicated page
- Pages are generated directly from real product changes
When a new PR merges, the system updates the corresponding page. Rather than appending new information, it rewrites the content to integrate changes in a way that reads coherently to customers.
This creates a continuously maintained representation of the product, rather than a static snapshot.
What Changes Downstream
The immediate impact is a shift in time and responsibility. A process that previously required weeks of coordination is reduced to minutes, with human involvement focused primarily on review and approval.
Brandon estimates this as roughly a 99.7% reduction in time spent across the workflow.
That shift changes how teams operate:
- PMMs spend less time reconstructing features and more time refining messaging
- Engineers see their work reflected externally without additional follow-up
- Customers gain access to more complete and up-to-date product information
- Marketing expands site coverage without increasing manual workload
As product output increases, the system scales with it, removing a key bottleneck between shipping and communication.
What Comes Next
This MVP establishes the foundation for a broader system where code continuously drives customer-facing content. The next steps focus on improving content quality, expanding coverage across more areas of the site, and validating workflows with internal teams.
Over time, the goal is to move from isolated page generation to a fully maintained website that reflects the product in near real time.
Building the Content Layer
Code to Feature Pages creates a direct connection between what is built and what customers see. By treating code as the source of truth, it removes the need for manual translation across tools and teams, allowing every merged PR to flow into the website as an update.
This is not just faster content creation. It is a shift toward a system where the website stays aligned with the product by default.
