Introducing Product as Code: Version Control for Product Management

#product-management#ai#development-workflow#productascode

I remember how much I liked the idea of GitOps when it first appeared. It was like fresh air into managing infrastructure. Infrastructure as Code transformed how we think about servers, deployments, and system configuration by making everything version-controlled, reviewable, and automated.

Something similar hit me when I realised you could do the same with product management. What if you could apply the same pattern to managing your product development?

The Problem: Context Starvation in AI-Driven Development

The biggest limitation I’ve hit with AI coding tools isn’t their technical ability—it’s the context problem. They can write great code, but they don’t understand why you’re building what you’re building.

Your product requirements are scattered across Jira, Confluence, Shortcut, Linear, GitHub Issues, Slack, and email. There’s no single source of truth. When your AI coding assistant needs to understand the business context behind a feature, it’s left guessing.

Meanwhile, your product decisions live in people’s heads or buried in presentation slides. When someone leaves the team, that institutional knowledge disappears. When you switch AI models or restart Cursor, all context is lost.

Enter Product as Code

Product as Code (PaC) treats product management with the same rigor as software engineering. Instead of scattered requirements across multiple tools, everything lives as structured, version-controlled data in your repository.

Here’s what a simple ticket looks like in Product as Code format:

user-auth-flow.yaml Product as Code v0.1.0 
apiVersion: productascode.org/v0.1.0
kind: Ticket
metadata:
  id: 22
  name: "user-authentication-flow"
spec:
  description: "Implement secure user login with JWT tokens"
  type: "feature"
  branch_name: "22-user-auth-flow"
  assignee: "@alice"
  acceptance_criteria:
    - "User can log in with email/password"
    - "JWT tokens expire after 24 hours"
    - "Failed attempts are rate limited"
  tasks:
    - id: 1
      description: "Create login API endpoint"
      done: true
    - id: 2
      description: "Add JWT token generation"
      done: false

This isn’t just a ticket—it’s structured data that AI tools can understand completely.

Why YAML?

I chose YAML for tickets because of the excellent tooling ecosystem. It’s easier to convert to other formats, easier to update programmatically, and more readable than JSON for humans. The structured format means AI coding assistants can parse business requirements, technical details, and implementation context in a single pass.

When your docs and tickets live as structured data in the same repo, AI tools can access the complete context: the business requirements from your epics, the technical approach from your specs, and the specific implementation details from your tickets.

This turns AI from a code generator into a true development partner that understands your product vision.

Two Immediate Benefits

There are two immediate benefits that make Product as Code compelling:

1. Documentation That Actually Stays Updated

Keeping docs up to date would finally make sense. First, it can be automated with AI tooling. Second, it becomes useful for keeping AI code generators on track. When your requirements live in the same repository as your code, updating them becomes part of the development workflow, not an afterthought.

2. Better AI Code Generation

I’ve found LLMs are significantly better at following structured tickets like this. They understand not just what to build, but how it fits into the broader product context, which git branch to use, and what the acceptance criteria are.

Product as Code serves as perfect memory for AI assistants. You can restart Cursor with a new agent and pick up exactly where you left off. You can switch models without losing context.

The Future: Technical People Managing Products

I strongly believe that in the future, work done by PMs will be mostly done by technical people. Product as Code bridges that gap by making product management feel natural to developers who already think in terms of version control, structured data, and automation.

Instead of context switching between Jira and GitHub, everything lives in the same ecosystem developers already know and love.

What This Enables

When your product requirements are version-controlled alongside your code:

  • Perfect AI Context: AI tools understand business requirements, not just code structure
  • Atomic Development Units: Each ticket maps to exactly one branch and pull request
  • Audit Trail: Every product decision is traceable through git history
  • No Tool Switching: Everything lives in the developer workflow you already have

Getting Started

I am currently working towards v0.1.0 specification at spec.productascode.org. Fill free to join the discussion on GitHub.

You can start experimenting today by:

  1. Converting a few of your current tickets to PaC format
  2. Testing how AI coding assistants respond to structured context
  3. Trying version-controlled product decisions in your workflow

The specification is open source and designed to be tool-agnostic. Whether you use Linear, Jira, GitHub Issues, or something else, Product as Code can bridge those tools with your development workflow.

What’s Next

This is just the beginning. I’m working on:

  • Web-based editors for non-technical team members
  • VS Code extension with live preview and validation
  • CLI tools for converting existing workflows
  • Rich media support for wireframes and design files
  • Integrations with existing PM tools

Personally, I can’t see any major downsides yet, but there will be some. That’s why I’m starting with the specification and core tooling, then expanding based on real-world feedback. Feel free to reach out to me if you have any feedback or questions.

If you’re interested in trying Product as Code or contributing to the specification, check out productascode.org and the GitHub repository.

Follow the Journey

Want to stay updated on Product as Code and my thoughts on the future of product development? Follow on:

The future of product development is version-controlled, AI-native, and developer-friendly. Product as Code is how we get there.

Want to dive deeper? The (not yet) complete Product as Code specification v0.1.0 is available at spec.productascode.org, and you can follow the project’s progress on GitHub.