With the launch of Opus 4.5 and the higher capabilities of coding agents, we started to question our workflows and created our new SDLC from scratch.

We actually expected the biggest impact on engineering, but actually our pms benefit the most and our devs are also happier. The main reason: Tools like Claude code are already boosting devs so we only improved their workflow. But PMs can only use dev tools like Claude Code or vibe coding tools like Lovable. None of them were really made to boost their abilities.

I thought it would be cool to share how our product teams are working now:

1. Ideation:

Our PMs dump in ideas, notes, emails, call recordings, screenshots. The idea agent sorts this and helps PMs curate.

2. Planning:

Based on ideas, the PMs + idea agent can start planning features based on the memory layer (which is basically the codebase translated markdown files). The planner is a collaborative doc where PMs, devs and the planning agent work in real time on the plan and iterate. Our flow: agent drafts plan -> humans make edits and add comments -> agent iterates on changes -> human review again -> this loop will continue till the plan is finished.

planning doc + planning agent

3. Issues:

When the plan is ready, the agent breaks down the plan into sub tickets with detailed descriptions about what and how to build. In addition, the agent recommends implementer and priority. The human must assign the tasks (or activate agent auto mode).

issue kanban overview

4. Implementation:

Based on assignments, humans, agents, or both together process issues through this flow: Backlog → ToDo → In Implementation → Agent Review → in Review. Agent tickets will be done by the agents in the background. If devs are assigned, they can pull their tickets using MCP into their terminal session and work from there. The status of these tickets is updated automatically via MCP.

5. Review & testing:

After implementation, a new review environment will spin up the branch for the product engineer to test what was built. Product review by PM, code review by our devs and agents.

https://preview.redd.it/s30v6ob0pusg1.png?width=2208&format=png&auto=webp&s=764df63db7e2caeb05fe645291cae9bb022845f5

6. Merge:

Once everything was reviewed, the branches will be merged into one final feature branch, that can be checked in another preview as well and then be pushed to staging. After that, it gets deployed in production through our Github releases.

_______

What our teams loves most:

• the planning mode is better than claude code, because its finally possibile to work together with multiple people in one place. the terminal session is only ok if you are a single person.
• the requirements are now clearer. It's happening less often that stuff was built differently than intended by the PM, bc the requirements now include exact frontend mockups and deeper technical planning thanks to AI.
• pms can handle simple changes, like padding adjustments by themselves. our devs dont get pulled out of their task for simple stuff. Instead, the devs can focus on the real problems that need their expertise & attention
• ticket status updates itself, when devs are pulling tickets via mcp into their local terminal session. no more pms pinging and asking about the status

This is how we are building software right now! Would love to hear what you are thinking about our current workflow and if your processes also changed that much in the last months!

Disclaimer: I'm a product engineer and I wanted the same output for our org. We built the needed software internally.

Anthropic's product lead Catherine Wu shared how they work now. They call it "docs to demos":

1. Skip the PRD
2. Build a working prototype with Claude Code in hours
3. Ship it internally to the entire company
4. Watch what people actually do with it
5. Iterate based on real usage

Some numbers: 90% of their code is written by AI. Engineers ship PRs with 2,000-3,000 lines fully generated by Claude. The bottleneck isn't engineering anymore, it's deciding what to build.

We wanted the same for us. So we developed this as our new workflow:

1. Ideation: dump of notes, emails, call recordings, screenshots. The idea agent sorts this and helps PMs curate.
2. Planning: Based on ideas, the PM + idea agent can start planning features based on the memory layer (which is basically the codebase translated markdown files)
3. The planner is a collaborative doc where PMs, devs and the planning agent work in real time on the plan and iterate. Our flow: agent drafts plan -> humans add comments -> agent iterates on comments -> again till finished
4. Issues: Based on the plan and the memory layer, the issue agent generates issues and recommends implementer and priority.
5. Implementation: humans or agents or both together process issues through the flow: Backlog → ToDo → In Implementation → Agent Review → in Review
6. Review: the PM reviews the build
7. Merge: Dev or PMs merge the branches

The cool thing about this? Our product engineers are upskilled. Small features of the whole process from idea -> review can be done without being dependent on a dev. If the feature is too complicated, devs can jump in on planning & implementation if needed.

Using this, we were able to reduce the overhead of sprint planning and so on to a minimum while enabling our non/ half technical product engineers to ship code and become builders.

I know that this isn't exactly what anthropic is doing (bc we don't have the large userbase anthropic has to evaluate features internally). But it boosted our output while making everyone in our org happier :)