A typical product-to-launch cycle at Gierd used to run three to six months – discovery, interviews, handoff, development, QA, launch, feedback – it's the typical rhythm for shipping software.

In this cycle the PRD is passed to Engineering to decode and design, rounds of questions, development, and QA ensue, and by the time anything ships, the user need that started the work has aged.

This year we quickly realized this process is an artifact of a model where every artifact in the cycle had a single consumer, a human, and every step waited on the next one to make sense of the last.

That model is closing. At Gierd, AI now shows up at every step of how we build. Not as a feature we bolted on, but as a consumer the cycle was redesigned around.

The Shift: Who Reads the Artifact Now

For most of Product's history, the consumer of a research synthesis was a Product Manager, the consumer of a PRD was an Engineer, and the consumer of a release note was an internal user. Quality equated to artifacts a person could read, question, and translate into the next step.

The consumer is changing. The Product Manager, the Engineer, the Designer, the User — they're all still in the loop, but they're working alongside agents now and the artifacts have to be readable by both.

A research synthesis written only for humans leaves the patterns implicit. A PRD written only for humans leaves the context that lives in the PM's head. A release note written only for humans takes a sprint to assemble.

My colleague, Nate Moran, wrote about this shift on the data side, how analytics engineering became context engineering when the consumer of data changed from human analysts to AI agents. Product is making the same move, for the same reason, at every step of the cycle.

How We Build Now

The product development cycle at Gierd now runs like this: discovery → synthesis → prioritization → PRD and prototype → engineering build → QA → release notes → feedback back into discovery.

That sequence isn't new. What's new is that every step has a context artifact attached to it — a transcript, a synthesis doc, a structured PRD, a working prototype, a phasing plan, an impact tracker, a release note draft. AI shapes those artifacts. Humans review and decide.

This works because two foundations are already in place at Gierd. The data underneath every feature is grounded in the Gierd Unified Schema. Engineering is already organized around agentic teams. Without those, AI in our cycle would be a productivity tool. With them, it's the spine of how we ship.

Where AI Shows Up Across the Cycle

1. Discovery and feedback synthesis. Customer call transcripts, sales call notes, support tickets, and inbound feedback used to consolidate quarterly at best. Now AI synthesizes across all of it and surfaces emerging themes as they emerge, not the quarter they accumulated. Discovery is no longer a phase, but continuous.

2. Phasing, prioritization, and impact tracking. AI helps consolidate tasks across resources, model feature phasing against capacity, and build impact projections that get revisited against actuals. Prioritization stopped being an expensive monthly executive alignment meeting, and became a continuously updated artifact the team operates against.

3. PRDs and specs that engineering agents can read. We built Gierd-specific PRD and spec skills on Claude. The output is a structured artifact an engineering agent can pick up and begin development against. The skill encodes the parts of context that used to live in the Product Manager’s head — acceptance criteria, edge cases, dependent systems, what "done" looks like. The spec flows directly into Linear, so the engineering workflow doesn't need a translation step. The PRD stopped being a handoff. It became a contract both engineers and agents work from.

4. Working prototypes shipped with the PRD. For features where look-and-feel matters, the PRD is paired with a working prototype built in partnership with Claude. It is an interactive HTML build with real charts, real flows, real interactions. We build them in hours, not days, and pass them alongside the PRD as a single artifact. Engineers get visual intent. Engineering agents get functional intent. The "I thought you meant…" cycles stop.

5. AFK Development. AFK is shorthand for away from keyboard. With the PRD and prototype in hand, engineering kicks off agentic development against that artifact. Schema work, back end, front end — the build runs while humans are away from the keyboard or while they’re doing other tasks. The team comes back to a draft to review and refine. This is the moment most teams still treat as the seam between Product and Engineering. We treat it as a single continuous artifact, picked up by an agent on the engineering side.

6. Standup automation. Standup transcripts run through an agent that extracts decisions, action items, and blockers. Owners get tagged in Slack. People who missed standup get a recap that's actually useful. The accountability mechanism isn't more meetings. It's a better artifact from the meeting that already happens.

7. Release notes that write themselves. Once code deploys, an agent assembles release notes from the deploy metadata and the feature spec, posts to the Feature Releases database in Notion, and drafts the Slack announcement for review. The feedback loop closes faster because the announcement and the documentation are no longer a separate workstream competing with the next sprint.

Seven moments. One Product team. Built on the same foundation Engineering uses for everything else.

Humans Stay in the Loop

None of this is autonomous. Every PRD is reviewed before it leaves Product. Every spec is reviewed by Engineering before it merges. Every release note is reviewed before it ships.

What changed is where the time goes. PMs spend less time documenting and more time deciding. Engineers spend less time decoding specs and more time architecting. Both spend more time talking to each other about the actual work, not about the artifacts that describe it. Same posture as the self-healing pipeline on the data side, agents propose, humans approve.

What Three Months Looks Like Now

The cycle that used to take three to six months now runs in roughly a third of the time. On average, we've seen 3x velocity across the work Product and Engineering teams have shipped this year. Two recent examples make that concrete.

Performance Intelligence, end-to-end. I drafted the PRD for Performance Intelligence reporting using our PRD skill in Claude. In the same session, I prototyped the dashboard, a working HTML build with real KPI cards, charts, AI-suggested actions, and marketplace breakdowns. I handed the PRD and the prototype to our Lead Engineer, Ryan Heneise, as a single artifact. Since this feature involved a new, experimental data flow, he started by creating a spike project – a branch that was meant to be tried and then thrown away – to prove the concept. Once the spike proved viable, he kicked off our first iteration of AFK development with agents, passing the right data from BigQuery to Postgres, building the back end, and building the front end. At the same time, our Front End Engineer, Jake Dahlgren, was working on the frontend, building charts, tables, and the structure that would become the presentation framework for the data layer. The work happened while we were all away from the keyboard. The team  reviewed and refined the result. The total cycle: roughly three weeks from kickoff to delivery instead of the three months a feature of that scope would historically have taken. Same scope, same rigor, a third of the time.

Traffic and Sales Dashboard, v1 and v2 in a week. We shipped v1 of the new Traffic and Sales Dashboard within days of initiating the feature request. We shipped v2 a week later, refined against the feedback v1 generated almost in real time. That cadence of version, learn, version again, in the same week wasn't possible before. The release wasn't the milestone, the iteration loop was. Data democratization for our customers got closer and faster because the iteration cost collapsed.

The velocity number isn't what we'd lead with internally. The thing that actually changed is the relationship with engineering. We're not handing off work anymore, we're building it together.

The Principle Underneath, and What's Next

There is no single moment in our cycle where AI made the difference. The difference is that AI is in every moment, and the artifacts at every step are now written for two consumers, humans and agents, instead of one.

The discipline underneath this is the same one Nate named on the data side. Analytics engineering produced clean data. Context engineering produces defensible answers. Product used to write specs for engineers. Now it encodes context for engineers and agents, at every step. Same discipline. Bigger surface.

The work described above is internal. It's how we discover, build, and ship. The next move is folding the same techniques into the product itself, so AI shows up in front of our customers, not just behind our team. We've built the foundation for improving feature discovery, quality, and velocity on our side. As AI becomes more capable we’re continually working to refine the process, tighten feedback loops, and deliver faster. The same techniques can put AI at the forefront of Gierd for the operators using us — proactive insights, alerts, and recommendations across merchandising, pricing, promo, listing, and inventory.

We rebuilt how we ship, now we're rebuilding what our customers experience.