In one project report, Kanfu Panda says three features reached review completion in 88 minutes using pdlc-skills, separate worktrees and processes, and a coordinating session. The run produced useful evidence about parallel work and quality checks—but its timings are one author’s account, not a benchmark or a promise of what another team will achieve.
What the project built—and how the features depended on one another
Panda’s project was a console the author ran personally. Its three features were cross-node review, notification filtering by task origin, and two review flags for a benchmark runner.
As an Amazon Associate I earn from qualifying purchases.
The benchmark flags depended on the remote dispatch and verdict-return path created for cross-node review. Origin-based notification filtering was independent, so it could be worked on alongside that dependency chain. That distinction shaped the schedule: two features had a dependency relationship, while the third could proceed separately.
How the work was split and run
The account describes three stages of preparation and execution, with a coordinating session responsible for decisions and final integration:
#1 Best Overall
- Turn requirements into plans. The pdlc-prd step generated three PRDs from raw requirements in 17 minutes, according to Panda. The coordinating session resolved ten open questions before implementation.
- Design in parallel. Design work ran concurrently across the feature efforts.
- Run each feature through the loop. Each feature went through TDD, implementation, and review using the loop engine. An outer Bash script scheduled feature processes in separate worktrees and observed dependencies.
Once all three reached the review terminal state, the coordinating session examined diffs and checks, opened pull requests, and handled release and deployment commands. The reported 88 minutes measures the time to review completion, not the entire project from initial requirements through release.
How long it took—and what the reported numbers mean
The report separates machine-run duration from personal effort. Panda estimated roughly two and a half hours of personal work across requirements, review, merges, and release-gate completion. That estimate is not directly comparable to the 88-minute machine-run figure: they describe different kinds of time and different scopes of work.
| Measure | Reported result |
|---|---|
| PRD generation | 17 minutes for three PRDs |
| Feature review completion | 88 minutes for all three features |
| Personal effort | About two and a half hours, estimated by the author across requirements, review, merges, and release-gate completion |
| Added code | 3,351 lines, including 1,770 test lines |
| Unit tests | 421 before; 516 after |
| Coverage | 89.6% before; 90.3% after |
| End-to-end cases | 52 before; 65 after |
| Acceptance registry gap | 19 feature acceptance items initially missing from the core-flow registry |
These are figures reported by Panda in 2026, not independent measurements. The article is a single account of one project run, so the results should not be treated as expected performance for other teams or codebases.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →What the checks caught—and what they did not
Each loop step had an objective command exit code as a check. After the feature work converged, the coordinating session reviewed diffs and checks. A release quality report then revealed a gap that a green suite for existing flows had not surfaced: 19 acceptance items from the new features were absent from the core-flow registry.
The author says those items were registered and nine end-to-end tests were added; the report passed afterward. This is a useful distinction between checking that existing automated flows still pass and checking that newly agreed acceptance criteria are represented in the release-quality system.
Acceptance on two machines tested deployment and cross-node review, but it was not a frictionless confirmation. The cross-node review reached the other machine, where the review command failed because that machine was not logged in; the result-return path still ran. Acceptance also exposed a missing lock around result collection. The report says deployment to both machines succeeded, but these observations do not establish that the workflow will be robust in other environments.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Why the timing records disagreed
The account warns against treating model-written state files as a reliable record of elapsed time or progress. In this run, state data had unreliable timestamps and inconsistent stage labels. The retro tool reported a median TDD duration of 2.1 hours, while polling by the outer script recorded 10, 21, and 13 minutes for the three features. Those values are not interchangeable: one came from the retro tool, and the others from outer-script polling.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Panda’s practical recommendation is to corroborate progress and duration with event-log, Git, and process-exit evidence rather than relying on state files alone. The discrepancy is a reminder that a workflow can automate execution without automatically producing trustworthy telemetry.
Best Value
What this run suggests about using the workflow
- Model dependencies explicitly. Cross-node review had to precede the benchmark flags, while notification filtering could proceed independently. The scheduler could use that structure rather than treating all three features as either fully serial or freely parallel.
- Keep step checks distinct from release checks. Successful command exits and a coordinating-session review were part of the run, but the separate quality report still found missing acceptance registry entries.
- Test the deployed path, not just the code path. Two-machine acceptance revealed an authentication problem on the receiving machine and a missing result-collection lock.
- Use evidence suited to the question. Process exits and event logs can help establish whether work finished; Git history and diffs help establish what changed. Model-authored timestamps alone did not settle duration in this example.
Panda summarized the human role this way: “Exactly two places need a human: deciding what to build, and deciding whether it ships.” In this project, that principle still involved substantial coordination: clarifying ten open questions, checking the converged changes, reconciling release criteria, and completing the release gates.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
