Published by Roast & Rise
Build Your Company Factory
Turn repeated work into supervised AI workflows - one workflow, one memory, one agent at a time.
Transform scattered automation into a supervised company factory: map a real workflow, pack your memory, design your first AI skill, track supervised runs, and decide when to scale. Direct, practical, grounded.
Course thesis
The leap from scattered prompts to real impact is a company factory: a supervised, memory-driven engine that turns repeated work into structured, reviewable agent workflows. The factory starts small - one workflow, one memory pack, one agent skill. Scale after proof, not before.
What you leave with
By the end, you can explain your first AI work factory, run one supervised agent workflow, and know what must be true before building bigger AI systems.
For
Founders, operators, managers, AI owners, and team leads responsible for improving work with AI inside their organization.
Workflow
Diagnosing, building, running, and evolving a supervised AI workflow for one critical company process - delivering real outputs and feedback in a controlled, reviewable way.
Change
Shift from scattered 'AI tasks' to building, running, and reviewing repeatable, supervised agent workflows that capture and grow company knowledge.
What you can do
Use these as checks while you move through the plan.
Surface and map a repeated workflow that is ready for AI-driven improvement.
Assemble a memory pack - facts, examples, rules, and edge cases required for quality outputs.
Design and document a bounded agent skill, with permissions, requirements, outputs, and review criteria.
Operate a supervised run board, tracking workflow executions, reviews, blockers, and quality findings.
Run a 30-day review and encode learnings, making the call to scale, redesign, or pause.
Chapters
01
Read The Work Floor
Map your first repeated workflow - make the unseen work visible, own it, and set the basis for a real AI assembly line. You'll go from hunches and fragments to a concrete plan showing every input, step, handoff, pain, and owner. This is your factory floor.
Why this matters in the workflow
You cannot automate what you cannot see. Most repeated work hides in backchannels, inboxes, habits, and system gaps - never on the org chart. Mapping the work floor exposes the truth: what really happens, who touches the process, what triggers it, where decisions get made (or stalled), and why it drains more energy than it should. This blueprint is where the AI factory starts. No plain whiteboard: you need the raw map, real frictions, and names on the line.
The working model
A company process, repeated often, is your assembly line. To build it as a factory - no chatbots, no magic - you need:
- Trigger: the event starting the workflow
- Inputs: what kicks in (data, requests, files)
- Steps: discrete actions, manual or digital
- Decisions: points where choices, reviews, or approvals happen (by person or system)
- Handoffs: where ownership or data passes (person-to-person, system-to-system)
- Systems: tools, docs, spreadsheets, chat channels, or apps used
- Pain points: blockers, delays, errors, burnout steps, or unclear ownership
- Current AI use: smart macros, templates, scripts, or automations already in place - and their limits
- Owner: one person who truly carries risk and authority on this workflow
Quality checklist
Shows each real step, decision, and handoff - nothing left to guessing.
Marks every tool or system used at each stage.
Annotates at least two pain points or blockers.
Names a real owner (not just a department/role).
Reviewed (even quickly) by a process participant before moving on.
Common mistakes
Using old process docs - missing today's reality.
Choosing rare or irregular workflows.
Missing the owner - no accountable person truly named.
Focusing only on steps, ignoring pain, blockers, or AI experiment history.
Not sharing the map for feedback before calling it done.
Checkpoint
Does your workflow floor plan show every step, decision, handoff, system, pain, and a clear owner - all confirmed by someone who actually does the work?
Exercise
Map Your First Workflow Floor Plan
Steps (15 min)
- Pick one workflow you believe is repeated. Use your calendar, inbox, or ask a peer if unsure.
- Talk with one person who runs it - get the real steps, decisions, handoffs, tools, pain points. Take rough notes.
- Draw the workflow (boxes for steps, diamonds for decisions, arrows for handoffs) - any format is fine: whiteboard, tablet, doc.
- Mark the owner by name. Annotate pain points with an icon or bold text.
- Share the draft map with someone who works this process for feedback - online or in person.
You now have a working map. This is your factory floor.
Use this at work tomorrow
Interview one team member today about their most repeated, frustrating process, map the steps and pain, and mark the owner - share for review before automating.
02
Build The Memory Pack
Capture every fact, rule, example, and edge case your agent needs. Make knowledge explicit - move from stories to source. By the end, you'll have a practical bundle your factory can run on, tested by the people who know the work best.
Why this matters in the workflow
An agent built on air will fail in production. Most companies hoard knowledge as stories, habits, or half-documented guides. To turn a workflow into a robust, agent-powered line, you need real memory: not just process steps, but the raw stuff of the job. Rules. Annotated examples. Common exceptions. Knowns and unknowns. This is the difference between a tool that mimics and a factory that produces quality you can trust.
The working model
Your memory pack is not a black box. Think of it as the raw material feed for your line: every important rule, source doc, example, edge case, and open question in one place, ready to be pulled at every run.
Quality checklist
Covers every major rule, not just the happy path.
Includes at least two annotated live examples (good and bad).
Links/pastes at least one real source or template document.
Names at least two edge cases or common pitfalls.
Lists at least one open or ambiguous question.
Reviewed by a domain owner, with feedback captured.
Common mistakes
Example section is empty, only rules listed.
No edge cases - assumes all runs are the same.
Source doc is a summary, not the actual working file.
Memory pack isn't reviewed by a workflow owner - missing live traps.
Annotations are missing - why examples worked/failed isn't clear.
Checkpoint
Can you hand your memory pack to a domain expert and have them confirm nothing critical is missing?
Exercise
Build and Review a First Memory Pack
In the next 15 minutes, you will assemble the raw material your agent workflow needs. This becomes your agent-ready memory pack.
Steps:
- Pick your workflow (from your floor plan). Name it at the top.
- List every rule or quality standard that shapes the output.
- Paste or link to two real examples (approved and rejected, if possible). Annotate why each succeeded or failed.
- List at least one source document or template used in the workflow.
- Name at least two edge cases, rare exceptions, or common pitfalls.
- Add one open question that remains unclear or debated.
- Share with a domain expert (the current owner of the workflow). Collect and note any gaps they spot.
Your output: A single page or doc with these raw materials, annotated and ready for review.
Use this at work tomorrow
Ask your workflow owner: 'If an agent did this tomorrow, what rules, samples, and gotchas would you give it?' Start your memory pack there.
03
Design The First Assembly Line
Pin down what your agent does, does not do, and how quality is managed - turn raw AI potential into a repeatable, reviewable workflow.
Why this matters in the workflow
Stray prompts and clever hacks aren't a workflow - they're a pile of loose wires. An agent only becomes useful when its job is defined as tightly as any human's on the factory floor. Boundaries prevent chaos. Clear specs make review possible. Consistency brings trust.
The assembly line begins with a single, bounded job for your AI: clear inputs, clear outputs, hard fences around what the agent handles and what it must never touch. Every step backed by a memory pack. Every output checked before it goes live. This is how you turn clerical AI into company infrastructure.
The working model
Quality checklist
Boundaries are strict and exclude adjacent processes or exceptions.
Every requirement points to specific, real inputs (doc, template, annotated example).
Permitted and forbidden actions are explicit - no grey zones.
Output template is concrete, with at least one real example or format.
Reviewer and standard are clear - owner signs off before go-live.
Common mistakes
Writing boundaries that overlap other jobs; agent over-reaches.
Specifying outputs abstractly, leaving room for guesswork.
Not naming a reviewer - approval falls through.
Leaving out forbidden actions; agent surprises the team.
Skipping domain expert feedback before sign-off.
Checkpoint
Can you show a filled-in agent skill card, walked through with a domain reviewer, and ready for the first live run?
Exercise
Draft Your First Agent Skill Card
Goal: Create a complete, reviewable skill card for the agent's first workflow step.
Follow these steps (target: 15 minutes):
- Open your mapped workflow and your drafted memory pack.
- Pick one workflow step that could move to an agent in the next 30 days.
- For that step, fill out the following structure - be concrete, link to real examples/templates where possible.
- Review your draft with a domain expert (even for five minutes). Adjust boundaries or templates based on their feedback.
- Save your version as the team's working agent skill card for that step.
Template is below.
Use this at work tomorrow
Draft your agent skill card, review it with an expert, and set the reviewer. Save the first version and prepare for real runs.
04
Run The Factory Board
Move from theory to practice: track, review, and learn from every run. The board is your factory's truth teller.
Why this matters in the workflow Static plans fool the eye. A real factory board reveals if your AI workflow delivers - where it struggles, who catches mistakes, how quality improves over time. Without a board, production is invisible. You can't correct for drift, confirm learning, or prove value.
The factory board is not a dashboard. It's the visible spine of your new workflow: every run, every review, every blocker, every adjustment - logged and findable by the team. It's where your repeatable process becomes a company memory, not just another experiment.
The working model
- Each run is logged. Capture who triggered, what inputs, which agent, and what came out.
- Review gates are enforced. A human reviewer checks and logs pass/fail, issues, and improvement notes for every output. No silent approvals.
- Blockers are tracked. If something stalls - missing input, unclear rule, system error - it's flagged, not brushed over.
- Learning is recorded. Every improvement, edge case, or repeated error should be noted for the weekly review.
This isn't bureaucracy. It's the pulse of your workflow. The run board is evidence - so the team can ask: is this working? What's actually getting better?
Quality checklist
All runs are logged, with no skipped steps.
Inputs and outputs are pasted or attached for each run.
Reviewer is not the same person as runner; review comments are included for all runs.
Every blocker is described plainly, not just labeled.
Learning notes show clear observations, not just generic remarks.
Board is shareable and findable for others in the team.
Common mistakes
Skipping log entries for runs - creates invisible work.
Allowing self-review or skipping reviewer comments - no learning is captured.
Writing generic or copy-paste learning notes - misses specifics.
Not updating blockers - problems recur without documentation.
Letting the board go stale - team loses trust in the process.
Checkpoint
Does your factory board show three complete, reviewed runs, with blockers and learning notes for each? Is the board up to date and visible to the team?
Exercise
Log Your First Three Runs - Factory Board Launch
- Open the Factory Run Board template below (or start a table with the same columns).
- Run your selected workflow three times - recording for each:
- Date and run number
- Who owned the run
- What triggered it (input)
- Which agent/skill
- The exact output
- Reviewer's name and comments (cannot be the same as the runner)
- Blockers that appeared
- Learning notes for each run
- After three runs, review your board. What patterns, issues, or improvements stand out? Share findings with your team or owner.
Deliverable: A run board with three complete, reviewed runs - including raw runs, reviews, blockers, and new findings.
Use this at work tomorrow
Run one real workflow and log it, review included - make the process visible before chasing scale.
05
Upgrade Into A Factory Pattern
Run a structured 30-day review of your first company AI workflow. Decide to scale, redesign, pause, or sunset. Document learnings, blockers, and gaps - then shape a repeatable pattern for future workflows.
Why this matters in the workflow
Factories don't just run - they improve, multiply, and shift direction with evidence. After 30 days, you know what actually works under real conditions: volumes, corner cases, review friction, where memory cracks, what your agent missed, and if the workflow did real work. That knowledge drives your decision. Keep? Change? Kill? This is where the assembly line becomes a pattern - or a lesson.
Without this checkpoint, you will keep running broken lines or scale a brittle prototype. Burn-in matters.
The working model
Quality checklist
Review memo includes real run data and reviewer input
Decision to scale/redesign/pause is clearly justified
Blockers and solutions are named, not glossed over
Pattern template is concrete - triggers, memory, skill, review
Output is shared with (at least) the team working the workflow
Common mistakes
Writing a memo based only on overall impression, not evidence
Leaving blockers undocumented or unresolved
Jumping to scale before output can clear review reliably
Filling in a template but skipping team communication
Pattern template too vague for others to reuse
Checkpoint
Can you document what your 30-day workflow proved, what you'll do next, and how the next workflow will copy or change your template?
Exercise
Write a Factory Review Memo and Pattern Template
You have completed 30 days running your pilot agent workflow. Now, cap the cycle: assess, decide, and template.
Steps:
- Gather your run logs, reviewer comments, output samples, and blocker notes.
- Interview the workflow owner and primary reviewer (10 min each) with these questions:
- Where did the agent struggle most?
- Which workarounds or quick fixes were needed?
- Was output quality acceptable - always, or only after reviewer edits?
- What slowed things down or created risk?
- Score: List each run and whether it hit the standards in the agent skill card/memory pack.
- Decide: For each main blocker, note if it was solved, deferred, or still open.
- Write your Review Memo (use the template).
- Outline a Pattern Template: the sequence, minimum memory structure, skill signature, review gates, and owner rules needed to re-run or build a new workflow.
- Share both with your team - schedule a 15-minute session to walk through findings and next moves.
Use this at work tomorrow
Book a review slot for your pilot workflow now; commit to writing and sharing your memo - before you scale or move on.
30-day path
Day 1-2: Run team interviews and workflow mapping sessions to choose the pilot process.
Day 3-6: Assemble the memory pack with examples, documents, rules, and edge cases.
Day 7-10: Draft the agent skill card, iterate with owner, and finalize review criteria.
Day 11-20: Launch the first supervised agent runs; log every step, review, and improvement.
Day 21-29: Refine memory and agent skill as blockers or quality issues appear.
Day 30: Complete the factory board, run a review session, and decide the path: scale, redesign, or pause.
Success signals
A fully mapped workflow floor plan for one real process.
A complete, reviewed memory pack.
A documented, reviewed agent skill card.
Three or more supervised run board entries with review feedback.
A factory review memo that leads to a decision: scale, redesign, or pause.
Reflection prompts
Where does this topic show up in real work?
What behavior should change first?
What evidence would prove this Riseplan worked?
Manager checklist
Choose one owner for the behavior change.
Use the exercise on live work.
Review the output before scaling the habit.
Decide what changes after 30 days.
In this library
Related RisePlans
Agentic Work Redesign Sprint
Learn how to redesign work for teams using AI agents to handle delegated, long-running, and cross-functional tasks. Build a new operating model that makes room for parallel delegation, reusable instructions, modern review cycles, and the next level of team collaboration.
From Chatbots to Superagents
Stop settling for one-off chatbot interactions. This plan shows you how to delegate real, repeatable work to AI agents with control, confidence, and results your team can trust.
AI Search Visibility: A Practical Sprint
Audit how your company appears in AI search, publish verifiable source pages, set crawler policy, and measure changes in Search Console.
Want this shaped around your company?
Risey can research your company foundation first, then build a version of this path around your real workflows, customers, and culture.
Start with your company