How a B2B PM Cut Requirement Work from 34 to 15 Person-Days with AI Workflows

Core Result: 34 → 15 Person-Days via Workflow Reorganization

In April 2024, a batch of B2B requirements originally estimated at 34 person-days (covering intake, communication, interaction design, documentation, and review) was completed in 15 person-days with no quality loss. The gain came not from skipping steps but from reorganizing the work loop: input context → AI reverse-questions → fill gaps → generate structured draft via Skill → human reviews boundaries, exceptions, system impacts → iterate .

Why AI in B2B Product Work

B2B product work is text-heavy, logic-heavy, and context-dependent. The real time sink is not typing but repeatedly organizing information, confirming rules, checking omissions, fleshing out exception branches, and turning verbal judgments into reviewable documents. When documentation becomes a mandatory organizational asset (for traceability, handover, retrospectives), PMs must (1) reduce low-value doc labor and (2) ensure docs are complete, accurate, and review-ready. AI excels at structuring scattered verbal input, making implicit rules explicit, expanding process branches and exceptions, advancing review materials from blank page to discussable draft, and codifying reusable experience into templates or Skills.

Three-Layer Goals

Short-term: Cut repetitive labor (meeting minutes, requirement structuring, flow branches, exception lists, acceptance criteria, open questions) so PMs start from a draft, not a blank page.

Medium-term: Reinvest saved time into business understanding, user scenarios, flow boundaries, exception handling, system linkages, and acceptance standards — because B2B products fail from unclear rules, not ugly UI.

Long-term: With Agent tools (Codex, Claude Code, Figma Make), PMs can push ideas faster into prototypes, design drafts, code comprehension, and verifiable states, but verification pressure rises accordingly.

Efficiency Change: 34 → 15 Person-Days

Phase-by-phase comparison:

Business communication: Old — repeatedly confirm background, goals, constraints. New — structure input first, then let AI reverse-question gaps.

Process mapping: Old — branches, exceptions, boundaries churn in head. New — AI helps lay out flows and exceptions.

Interaction design: Old — draw long before discussion. New — generate discussable version first, then human-correct.

Document writing: Old — build structure from blank page. New — use template/Skill to generate draft.

Review adjustment: Old — review exposes many omissions. New — surface to-confirm items upfront.

Old way: mental looping — "Did I miss this branch? How to handle that exception? Does this page link to that system? Does the rule affect old flow? Can QA verify?" New way: iterative loop — input context → AI questions → fill context → generate draft → human review → repeat . Division of labor: AI = laborer (organize, draft, question, structure, check gaps, phrase) ; Human = decider (judge business goals, confirm boundaries, rule on exceptions, assess system impact, own review conclusion, accountable for result) . In core transaction logic (cashier, payment, reconciliation, pricing), AI may analyze, explain, suggest, flag anomalies, and organize docs, but core logic must stay deterministic, verifiable, traceable.

AI Application Evolution: Prompt → Context → Harness

Prompt Engineering: How to ask clearly? Role setting, step-by-step thinking, few-shot examples, output format constraints. Entry point but hits ceiling fast.

Context Engineering: How to give enough context? Feed docs, screenshots, code, historical rules, business background. Real quality lever: "AI isn't dumb; it's missing materials." In PRD work, most time is spent doing Context Engineering — explaining background, digging up old rules, clarifying interface and system relationships, converting mental judgments into AI-readable info.

Harness Engineering: How to put AI in the real workplace? Give tools, file system, permissions, execution environment, verification loops. Agent tools (Codex, Claude Code) let the model read files, call tools, modify files, check results, iterate. Same model in different harnesses can differ by an order of magnitude. Evaluate tools by whether they can enter the workplace, read context, call tools, and close the verification loop.

Two Highest-Leverage Scenarios

1. PRD Writing: Four-Step Method

Build PRD Skill: Codify doc structure, rules, terminology, and gotchas. Reuse instead of re-explaining template each time.

Feed Known Key Nodes: Before invoking AI, clarify goal, core flow, key rules, main entities, impact scope, and uncertainties.

Let AI Reverse-Question: Don't rush to generate. Have AI ask about import format, failure strategy, permission control, exception prompts, historical data impact, etc.

Invoke Skill to Generate Doc: With context and key questions filled, generate; accuracy jumps. AI owns draft and structure; human owns judgment and sign-off.

Example: PRD Writer Skill created via Codex Skill Creator, fixing chapter order, table headers, trigger scenarios, and annotation rules for missing info. AI must not receive a half-baked requirement and make product decisions; it's best at organizing, questioning, and phrasing.

2. Interaction Design: Fast Visualization, Not Judgment Replacement

Tools like Figma Make, Figma MCP let AI enter design tools to generate page structures, flow sketches, interaction schemes. Value: quickly visualize ideas, produce a discussable version, lay out flow and page relationships, then human judges around real screens. Human must still decide: page hierarchy rationality, user path smoothness, exception state completeness, business rule clarity, dev feasibility, test verifiability. Old way: draw long then review. New way: AI scaffolds skeleton, then discuss around real visuals — especially valuable early.

Skill: Turn Personal Experience into Reusable Assets

A Skill is a small methodology packaging task goal, workflow, input requirements, output format, quality standards, and boundary rules — not just a prompt. "A good Skill equals working for your future self." Any task done twice is worth codifying: writing PRDs, weekly reports, organizing API docs, competitive analysis, interaction reviews, meeting minutes, impact analysis. Build Skills by running real demands first, then extracting patterns. Don't start from scratch; stand on mature methodologies: Apple Human Interface Guidelines, awesome-design resources, high-quality GitHub Skill repos. Localize mature specs into Skills, then let AI design/document against those specs — more stable than relying solely on personal experience.

Learning AI: Information Sources Determine Ceiling

Four standards for high-quality sources: Stable (continuous tracking), Credible (first-hand, official, real practitioners), Real (business practice, product judgment, failure stories), Frontier (latest tool/model/industry shifts). Short videos give leads, not systematic judgment. Invest 4–5 hours weekly in long-form content: CEO-level and core-practitioner long interviews (3–4 hrs, raw, unpolished, full of first-hand judgments). Prioritize voices building models, products, companies: Hassabis (DeepMind), Dario (Anthropic), Sam Altman (OpenAI), Musk (xAI), plus their researchers and product leads. Domestic channels (Web3天空之城, 水球泡, 张小珺商业访谈录, 晓辉博士, 老罗和他的十字路口) serve as translation/interpretation entry points; cross-verify with primary sources.

Methodology Summary: Four Key Points

One number: 34 → 15 — AI value is workflow reorganization, not process omission.

One worldview: Prompt → Context → Harness — AI moves from answering to context-aware to tool-using in the workplace.

One workflow: PRD four-step + Skill compounding + mature specs — build Skill, feed key nodes, AI reverse-questions, generate PRD; repeatable doc workflow.

One info diet: Stable, credible, real, frontier — learn via high-quality long content, not short-video hype.

Premise remains: Human decides, AI labors.

Five Practical Insights

Use strongest model for critical tasks: Don't over-optimize model cost; human time is pricier. Respect company security/compliance — no sensitive data in uncontrolled envs.

Build feel through continuous use: AI is learned by doing. Start small: organize minutes, structure verbal requirements, list exception branches, check PRD gaps, translate API docs to product language, apply design specs to pages.

Distill experience into Skills: Everything done twice deserves a Skill — personal productivity compounding.

Try new tools early, don't anxiety: Codex, Claude Code, Claude Design, Figma Make, Gemini represent different explorations. Immaturity is normal; adopt directionally, then decide on long-term workflow inclusion.

Know a bit of fundamentals to avoid superstition and misses: Why models hallucinate, why context matters, why Agents need tools, why generated content must be verified, why same model differs across tool environments.

Boundaries & Risks

1. Depend but don't fully depend. AI hallucinates confidently. Interfaces, data, policies, historical rules, system boundaries — verify against source materials. Safer pattern: AI reads, AI organizes, AI flags doubts, human confirms key conclusions.

2. AI is assistant, not accountable party. Docs need human ownership; solutions need human review; business outcomes need human accountability. Outsourcing judgment isn't using AI — it's evading judgment.

Replicable Agent Task Flow

Example: "B2B backend add batch user import module". Steps: (1) Give background to AI; (2) AI reverse-questions details (import format, failure strategy, permission control, exception prompts); (3) Fill context; (4) AI generates PRD or interaction prototype; (5) Human checks and corrects. This is a loop: input context → AI questions → fill context → AI drafts → human reviews → iterate , not a one-shot command. Effective AI use is iterative human-AI collaboration.

Appendix: Seven Real-World Case Studies

Case 1: Payment Settings Optimization

Background: Redesign existing B2B payment settings page using Apple HIG style, preserving real business logic and interaction states. Method: (1) Deploy awesome-design-md GitHub repo principles as local design-md Skill via Codex. (2) Capture real page: Codex simulated login, got session cookie, detected iframe ( mainBox), extracted payment method list, toggle states, modal structures. (3) Replicate + iterate: based on real structure, generate prototype per Apple style rules, then refine modals, search, batch settings, shortcuts, payment methods. Key pivot: Not "AI draw a pretty page" but "AI reads real page structure, then mature design spec constrains solution." Lessons: Don't treat AI as drawing tool; deploy mature specs as Skills. Agent must fetch real page structure first; guessed prototypes detach from business. B2B backend design core is clear hierarchy, not aesthetics. "Whack-a-mole" issues in iteration are normal — step back to overall layout logic.

Case 2: PRD Writer Skill沉淀

Background: Didn't start with Skill; first ran real demand "Raw Material Archive Support Delete". After run, fixed patterns emerged → built Skill. Steps: (1) Upload company PRD PDF template (scanned, no text layer). Codex installed PDF rendering lib, converted 6 pages to images, OCR'd each, extracted 5-section framework: Overview, Overall Flow, Functional Requirements, Non-functional Requirements, Release Notice. (2) Run real demand through framework. Codex generated draft covering background, delete flow, validation sequence, exception prompts, upstream/downstream dependencies, test acceptance points, and simultaneously surfaced to-confirm items (cost card, diff sheet, accounting-side validation). (3) Tried auto-filling Feishu online doc — briefly worked but later drifted (fill one cell, jump elsewhere; undo misfires). Stability insufficient. (4) Codify full workflow into Skill via skill-creator, fixing chapter order, table headers, trigger scenarios, missing-info annotation rules. Key pivot: Online doc auto-fill unstable, but struggle forced more valuable outcome: codify PRD workflow as reusable Skill. Lessons: Skills emerge from running real demands, not design. Agent filling online docs currently unreliable; copy-paste + human check is steadier. Anything done twice deserves a Skill. Structured experience enables compounding.

Case 3: AI Ordering Interaction Design

Background: Cashier system adds AI dish recognition and fixed-amount checkout. Not single-page but full interaction chain: trigger, confirm, correct errors, swap dishes, adjust prices. Method: (1) Use Gemini to run interaction logic: describe biz scenarios/flows, get React interactive prototype. Real iterative loops: single-dish confirm modal too heavy → batch checklist; add recognition area annotation (left snapshot ↔ right list index); add total price edit (quick +/- and direct input); Android cashier lacks physical keyboard → custom numeric soft keyboard; swap dish interaction from "click dish name" to "dedicated text button" for touch. Emergent logic: after swap, report training data? Reporting affects next recognition; not reporting doesn't. (2) Move code to Figma MCP for visual polish: dark→light, fix dish line wrap, change prompt area from button-feel to pure text bar. Output: Complete AI recognition cashier interaction scheme: Trigger → Recognize → Confirm/Correct → Swap Dish → Price Adjust → Settle. Every node has interaction states, ready for review. Lessons: Agent tools suit complex but structurable design tasks. Code prototype for logic first, Figma for visual second — each tool does what it's best at. Don't expect one-shot correctness; each iteration solves one concrete problem. Design process surfaces logic not in requirements (e.g., "report training data after swap?").

Case 4: AI Sharing Material Generation

Background: Team AI experience sharing, tight deadline, PPT not started. Claude Design launched Apr 18, tried Apr 19 midnight, 10-min output (content already prepared). Method: (1) Feed info first: Claude Design asks questionnaire — audience, duration, goal, personal background, high-frequency scenarios, killer cases, style — all clarified. (2) After 22-slide draft, upload handwritten PPTX notes. AI found timeline drift, buried highlights, retrospective missing new content. (3) Align item by item: add "Info Source Four Elements" and "Four Giants" as separate slides; upgrade retrospective from 3 to 4 key points; rewrite all speaker notes in own voice. Final 34 slides with full script. Lessons: For sharing materials, specify audience, duration, goal, style, key cases — don't just say "make PPT". After draft, feed notes/old materials/drafts to let AI find gaps. AI can be editor and reviewer, not just generator.

Case 5: Cashier System Large PRD (the 34→15 case)

Background: Five modules concurrently: POS invoicing, partial refund, manual discount, dish data localization, dish sorting optimization. Each has upstream/downstream deps; cross-module logic intersections. Old estimate: 34 person-days. Method: (1) Put AI in planning mode : first input = five raw demand descriptions + "Don't generate yet. I'll feed info piece by piece; we communicate until no logic gaps, then generate." Critical: if AI generates first, you enter "modify draft" mode, thinking follows AI; if AI questions first, you actively clarify, final doc quality differs entirely. (2) AI progressively flagged key puzzles: Haibo order likely not generated right after payment — whose QR on receipt? Can mixed-payment orders invoice? Must specified-amount refund select dish? Manual discount vs marketing activity priority? After partial refund, can already-printed invoice QR still work? (3) These questions forced core rules upfront: invoicing flow = apply invoice link → print QR → wait Haibo order → scan QR to actually invoice; specified-amount refund dropped (scope halved); manual discount priority > marketing, cancel manual → marketing auto-restores; uninvoiced can invoice remaining, invoiced goes red-invoice logic. (4) Invoke PRD Writer Skill for draft. ~80% structure usable; mainly supplement exception copy, to-review item boundaries, cross-system linkage descriptions. (5) Review: dev said "refund-invoice relationship clear this time; used to ask after review." Red-invoice method marked "to-review, option A/B"; finance discussed that item directly, no runaround. Key pivot: 34→15 not from cutting process but changing workflow: Context input → AI questions → align item by item → Skill generates draft → human confirms boundaries/exceptions . Lessons: Large demands: don't let AI write first; pull AI into clarification mode. Cross-branch issues easiest to miss — let AI do relationship checks. To-decide items must be explicitly flagged, not pretended settled. AI draft value isn't one-shot perfection but freeing human from blank page.

Case 6: API Doc Readability

Background: Xiao Jingling scan-to-order integrates with JD Haibo catering SaaS. Goal: user scans via Xiao Jingling, order lands in Haibo (digital management system). Commodity, inventory, order infra all on Haibo; Xiao Jingling only entry. Owner of commodity part: establish bidirectional commodity binding — commodity pull, SKU bind, order translation, status sync. Method: (1) Set context, let AI reverse-question: two systems connect, Haibo provides API, Xiao Jingling consumes, I lead commodity part, need overall plan + interface list + field mapping. AI asked: which data models accessible? which output first? who leads, who supports? Value: forces boundary/resource clarity before writing. (2) Feed materials: Haibo backend commodity management screenshots + Xiao Jingling API docs. AI extracted interface purpose, key fields, params, returns, call timing, error codes from API docs; translated tech language to product language; output field mapping. Boundary clear: AI does first-layer translation; interface meaning and system boundaries still need dev confirmation — can't finalize on AI summary alone. (3) Generate V1.0, mid-stream catch logic error: saw "sold-out push" section — Haibo has no sold-out/out-of-stock concept, only on/off shelf. Proposed: Haibo only off-shelf, should map to Xiao Jingling off-shelf? AI counter-questioned: Haibo inventory module truly no sold-out concept, or just not seen? Affects webhook event design. Critical: sold-out (today sold out, may restock tomorrow) vs off-shelf (removed from menu, no longer sold) — different biz logic and interface design. (4) Iterate V1.0→V1.1→V1.2, final doc covers background, user analysis, metrics, glossary, functional reqs, interface list, release notice. Incidentally created channel-product-integration Skill: integration mode judgment, info collection checklist, field mapping template, PRD template. Next new channel integration reuses directly. Lessons: Don't let AI write on receipt; set context, let AI reverse-question to surface hidden rules. AI good for first-layer tech material translation; critical conclusions back to source and dev. Mid-stream errors normal — AI draft value is earlier problem exposure. Done-once projects deserve Skills.

Case 7: Token E-ink Display Hardware

Background: 4.2" tri-color e-ink (electronic shelf label) to show real-time Claude Pro remaining quota on desk as ambient awareness — no need to open tool, glance to see. No off-the-shelf solution; must figure screen driving, data pull, scheduled refresh from scratch. Method: (1) Screen integration not simple. Device names ZKC42V and ESL_BWR given to AI: retail e-label, Zkong proprietary protocol, no open driver, needs dedicated base station hardware. Dead end? Found web tool that pushes images via Bluetooth. Pivot: bypass proprietary protocol, use web tool's Bluetooth channel. (2) Reverse-engineer web protocol: feed web source to AI, analyze Bluetooth comms. AI extracted full GATT structure, command byte table, packet format, chunked transfer logic from JS. Value: no packet capture, no firmware reverse, just read frontend JS to get protocol. (3) Agent writes full solution, debug on the fly: Python script pulls Claude Pro quota, generates black-white+red dual-channel image, pushes via BLE, cron every 5 min. Real hardware issues: CoreBluetooth cache → TimeoutError; limited device advertising window; app icon occasionally disappears. Final: menu bar quick button, LaunchAgent, opportunistic push mechanism. Final system: epd_daemon.py (BLE push daemon, scan→push, skip if not found), epd_manager.py (menu bar manager, manual trigger + Bluetooth toggle), cron job (every 5 min). Lessons: Unknown hardware: first clarify protocol, then judge feasible path — don't code blindly. Web tool JS is goldmine — Web Bluetooth API logic all there. Hardware projects must accept repeated debugging (TimeoutError, advertising window, cache issues are real). Agent tools fit "idea → make it run" tasks: from protocol analysis to full script to menu bar app, all in Codex.

Appendix Epilogue

Across seven cases, one thread: Every successful use had human think clearly first, then AI performed well. PRD Writer emerged from real demand runs, not design. Payment settings page captured real structure first, not guessed. Cashier five branches aligned logic first, then generated. E-ink clarified protocol first, then coded. AI best handles repetitive labor, structural labor, draft labor, material organization — helps write docs faster, prototype faster, understand interfaces faster, turn ideas into discussable artifacts. But it cannot replace final accountability: business goals, flow boundaries, risk trade-offs, review conclusions remain human. True AI users don't outsource judgment; they excel at organizing context, asking questions, codifying methods, verifying results. That's the real answer behind 34→15: not what AI did for you, but that you put energy back on what only humans should do. AI game just started. Start using, learn by doing, codify what's reusable — matters more than chasing hype.