Chapter 15 — Building Your AI-Enhanced Workflow

“You do not rise to the level of your goals. You fall to the level of your systems.” — James Clear, Atomic Habits

“So teach us to number our days that we may get a heart of wisdom.” — Psalm 90:12 (ESV)

Why This Matters

For fourteen weeks you have been building parts. You learned to prompt like a professional communicator, to pick the right tool instead of defaulting to one, to verify a summary against its source, to catch a hallucination, to delegate a multi-step task to an agent and keep the leash short, to know what you must never paste into a public chatbot. Each of those was a rep on one muscle.

This week we assemble the muscles into a body of work. Because here is the uncomfortable truth about AI in a real job: almost nobody fails at it because they cannot write a good prompt. They fail because they never designed where AI fits — so it fits nowhere and everywhere at once. They paste a little here, skip verification there, use the frontier model to reword a one-line email and the free model to analyze a contract, and at the end of the week they cannot tell you whether AI made them faster, slower, better, or sloppier. They have tools but no workflow.

A workflow is not a list of apps. A workflow is a designed sequence: this recurring task, broken into steps, with each step assigned to the human or to an AI, with a verification gate wherever a mistake would cost something, and with a measure so you know whether it is actually working. That is the whole of this chapter — and it is the pivot that turns “I use AI sometimes” into “AI is part of how I work, on purpose, where it belongs.”

And it is exactly where the spine rule of this whole book comes to rest. Say it with me one more time, because you will build on it all week:

You choose the tool. You own the verdict. AI drafts, generates, and accelerates; the professional decides, verifies, and is accountable. AI is an assistant, not an authority.

Designing a workflow is the act of deciding, in advance and in writing, where the AI accelerates and where you keep the verdict. Do it well and you buy back hours a week for the work only you can do. Do it carelessly and you automate your own mistakes at machine speed — and slowly lose the skill you would need to notice.

This week’s question sits underneath all of that, and it is not decoration. “So teach us to number our days that we may get a heart of wisdom” (Psalm 90:12, ESV). Your days are finite and numbered. A workflow is a claim about what your hours are for. So the real question of this drill week is not “how do I use AI more?” It is: what does it mean to order my time and my work well — to number my days — so that the hours AI gives back are spent on what actually deserves them? Hold it. We will earn it near the end.

Coach’s Note — This is a drill week. There is no separate project file. The graded lab lives inside the exercises, and it is the real thing — you will map your own week, design one AI-enhanced workflow, analyze a workplace scenario, and measure a result. The reps below are the training; the lab is the meet. Show up for both.

15.1 — Your Week Is a System: Map Before You Optimize

The single most common mistake I see is optimizing a task the person should not be doing at all. AI makes a bad process faster, which feels like progress and is not. So before you automate one thing, you map.

Mapping means writing down the work you actually do — not the work you think you do. For one honest week, keep a rough log of your recurring tasks. For each, capture four things:

That last column is the one people skip and it is the most important. A rule-shaped task — “turn this transcript into action items,” “reformat these numbers into a summary table,” “translate this notice into Spanish” — has a describable procedure and a checkable output. A judgment-shaped task — “decide whether to escalate this client complaint,” “give this employee difficult feedback,” “sign off on the budget” — depends on context, relationships, and stakes that live in your head and your accountability, not in a procedure.

Rule-shaped work is where AI earns its keep. Judgment-shaped work is where you earn yours. Most real tasks are a blend — and the art of the workflow is splitting the blend at the seam.

We ship a mapping template for exactly this: code/weekly-workflow-template.txt. Fill it in this week before you touch a single tool. You cannot optimize a system you have not drawn.

Coach’s Note — Do the map by hand, on paper or in a plain doc, before you ask an AI to help you make it. If you let a chatbot invent your week for you, you get a plausible-sounding week that is not yours — and you will have skipped the one part of this exercise that requires you to look honestly at your own time. Number your days, not a generic professional’s.

15.2 — The Triage Decision: Do It Yourself / Delegate to AI / Never Delegate

Once your tasks are on the page, every one of them gets sorted into exactly three buckets. This is triage, and it is the beating heart of an AI-enhanced workflow.

Bucket 1 — Do it yourself (AI stays out). The work where the judgment, the relationship, or your accountable name is the deliverable. Hard conversations. The final decision. Anything where you could not verify an AI’s output because you are the source of truth. Anything that carries your professional or legal sign-off. If being wrong here is catastrophic and un-catchable, the human does it start to finish.

Bucket 2 — Delegate to AI, then verify (the assist zone). The rule-shaped, verifiable, high-volume, or blank-page work. Drafting. Summarizing. Reformatting. First-pass translation. Brainstorming options. Turning a transcript into notes. This is where most of the week’s time savings live — because you can check the output against a source or against your own knowledge. The AI drafts; you own the verdict.

Bucket 3 — Never delegate (and never paste). A hard line, not a soft preference. Confidential client data, PII, PHI, anything your employer’s policy or the law forbids putting into a public tool. Decisions that must be made by an accountable human by rule (many legal, medical, financial, and HR judgments). And the verification step itself — you never delegate the checking of the AI to the AI. Appendix C is the authority here: see Appendix C for what may never leave your organization’s walls.

Here is the triage in one table. Copy it into your template.

The mistake in both directions is real. Over-delegate and you paste a client’s medical detail into a consumer chatbot, or you let a model make a call that was yours to make. Under-delegate and you spend Sunday night hand-formatting a table a model would have built in nine seconds while you did something that mattered. Triage is how you stop making both mistakes.

Coach’s Note — When you are unsure which bucket a task belongs in, ask one question: “If the AI got this subtly wrong, would I catch it before it did harm?” If yes, it can go in the assist zone with a verification gate. If no — if a quiet error would ship straight to a client, a patient, a judge, or a payroll run — it is not an assist task. It is yours.

15.3 — Spotting Automation Opportunities

Inside the assist zone, some tasks are worth turning into a repeatable piece of workflow — a saved template, a standing prompt, or even a light agent (Chapter 13). Not everything is. Here is the test I want you to run on each candidate. A task is a strong automation opportunity when it scores “yes” on most of these:

1. Recurring — you do it often enough that the setup pays back. A once-a-year task is rarely worth automating.
2. Rule-shaped — you can describe the procedure clearly enough that a competent stranger could follow it. If you cannot write the steps, an AI cannot reliably do them.
3. Verifiable — the output can be checked against a source or a standard in less time than doing it from scratch. Cheap to check is the whole game.
4. Bounded stakes — a miss is annoying, not catastrophic; or the verification gate reliably catches misses before they ship.

Score high on all four and you have found gold: turn it into a reusable prompt template (that is your Chapter 12 library) or, for a multi-step version, a delegated agent task with a human approval gate (Chapter 13). Score low on rule-shaped or verifiable and leave it as a one-off, human-led task — automating it just buys you faster, less-catchable errors.

Watch for the tell. Any time you find yourself typing nearly the same prompt for the third time — the same “summarize this meeting into decisions, owners, and dates” or “rewrite this in plain language for a non-expert” — that is a recurring, rule-shaped task announcing itself. Capture it as a template with fill-in blanks. The signal for automation is repetition you can feel in your fingers.

Coach’s Note — There is a difference between assist and automate that trips people up. Assist = the human runs the task and pulls in AI at a step. Automate = the task runs with less human touch, sometimes on a schedule or via an agent. Move a task from assist to automate one notch at a time, and never past the point where you would fail to catch a bad result. The autonomy you grant should always trail the verification you can actually perform.

15.4 — Choosing the Model for the Step

You learned model selection back in Chapter 3. In a workflow it stops being a one-time choice and becomes a per-step choice, because a single workflow can touch three different tiers of model in five minutes. Right-sizing the model to each step is the cost-and-quality discipline of the AI era — the same instinct as not booking a moving truck to carry one grocery bag.

Two dials, both set per step:

The capability dial — how hard is the thinking? Match the tier to the difficulty of the step, not the importance of the project.

The capability kind — what shape is the step? Sometimes the right model is not “smarter,” it is specialized:

• Long contract, report, or codebase in one go → a long-context model (Claude and Gemini reach roughly 1M tokens as of mid-2026).
• Anything with video or audio to understand → Gemini’s native multimodal, or a dedicated meeting/transcription tool.
• A fact that must be current (“what did the board announce this morning?”) → a real-time / answer engine — Perplexity, Grok, or a Deep Research mode — and check the citations.

Prices and version numbers move weekly — treat every figure as a mid-2026 snapshot and confirm on the vendor’s page; pin the model ID in your notes, not the marketing name. The full tier ladder is Chapter 3’s whole subject; Appendix B is the tool directory. The point for your workflow is simply this: do not run every step on the same model out of habit. Reaching for the frontier tier to reword one sentence is the AI era’s version of overspending; reaching for the cheapest tier to analyze a contract is the version of being penny-wise and disaster-foolish.

In BoodleBox. At Concordia this per-step choice is one gesture, not an app-switch. In BoodleBox — the platform CUW licenses (sign in at box.boodle.ai with your Concordia account) — you type @ to open the bot picker and choose the model the step needs, and you can pull several models into one chat to compare them side by side. Its AI Models list maps straight onto the tiers above: a fast bot for classify-and-extract, a balanced bot for everyday drafting, a frontier bot for the hard, long-document reasoning — and its token-reduction design is built to keep that affordable (as of 2026). Model names drift, so @-mention by the action, not the label. Off campus or without a login, the same discipline runs across the public free tools in Appendix B.

15.5 — Composing Tools: One Workflow, Several AIs

A mature workflow is rarely one app. It is a relay — an output handed from tool to tool, each doing the leg it is best at. Picture a common professional chain for turning a client meeting into a deliverable:

1. A meeting/transcription tool (Otter, Fireflies, and peers) captures and transcribes the call.
2. A general assistant (Claude, ChatGPT, Gemini) turns the transcript into decisions, owners, and dates.
3. You verify every commitment against what was actually said — this is the gate, not an optional polish.
4. A document or slide tool shapes the verified notes into the client-ready deliverable.
5. You sign it. Your name, your verdict.

Notice two things. First, the seams between tools are where errors hide. Every hand-off is a place a name got dropped, a number got transposed, a “we should consider” got upgraded to “we decided.” Verify at the seam — the moment data crosses from one tool to the next is the moment to check it, because that is where nobody owns it. Second, notice how few tools it actually takes. The temptation is to collect apps; the discipline is to compose the fewest tools that cover the legs, each with a verification gate where the stakes justify one.

Coach’s Note — More tools is not more capability; it is more seams to verify and more subscriptions to pay for. I would rather see you run a tight three-tool relay you fully understand than a ten-tool Rube Goldberg machine you cannot audit. When you add a tool to a workflow, you are adding a place where the verdict can slip. Add it only when a leg genuinely needs it.

In BoodleBox. Several legs of a relay like this can live in one place. In a single BoodleBox chat you can @-mention one bot to draft and another to check it, keep your source files attached as Knowledge so the AI stays grounded in your documents, and — when the work is shared — open a Box (a group chat that holds people and bots) so a colleague or your professor works in the same thread, with Folders keeping the week’s chats organized. The seams do not vanish, though: even inside one platform, verify at every hand-off — the moment one bot’s output becomes another’s input is still where a name gets dropped. Voice or video capture may still need an outside meeting tool (as of 2026); route its transcript back in for the rest.

15.6 — Measuring What Matters: Time Saved and Quality Gained

If you cannot say whether the workflow helped, you have a hobby, not a system. The epigraph is not an accident: you fall to the level of your systems — and a system you do not measure drifts. So measure two things, always both:

Time saved. Baseline first. Before you AI-enhance a task, time the manual version honestly — including the parts you forget, like formatting and re-reading. Then time the AI-enhanced version including verification — because verification is not overhead you get to ignore; it is part of the real cost. The honest number is (old time) − (new time with checking). Sometimes that number is smaller than the hype promised. Report it anyway; an honest small win compounds.

Quality gained. Faster-but-worse is a loss dressed as a win. Track a quality signal alongside the clock: how many revisions did it take? How many errors slipped through and had to be fixed later? Did the recipient understand it the first time? For some tasks, quality is the whole point and time is secondary — an AI that helps you catch three errors you would have missed is worth more than one that saves ten minutes.

A dead-simple before/after log is enough:

Task: Weekly client status report
                       Manual (baseline)   AI-enhanced (with verify)
Time per occurrence:   ~55 min             ~20 min
Revisions to final:    2                   1
Errors caught later:   1 (a wrong date)    0
My verdict:            Keep. Real win, and the date-check gate paid off.

Beware the vanity metric: “it felt faster.” Feelings are not measurement. And beware measuring only speed while quality quietly erodes — that is how a team gets fast at shipping things nobody checked. Measure both, write it down, and let the numbers — not the excitement — decide whether a workflow stays.

15.7 — Guarding Against Overreliance and Skill Atrophy

Now the counterweight, and it is not optional. A tool that does a thing for you, used long enough, quietly erodes your ability to do that thing yourself — and worse, your ability to judge whether it did it well. Human-factors researchers have a name for the trap: automation bias, the well-documented tendency to over-trust an automated system and stop checking it, precisely because it is usually right. Usually-right is the most dangerous kind of tool, because it trains you to stop looking.

For the AI-enhanced professional this shows up as two related risks:

• Skill atrophy. If you never draft from a blank page, you slowly lose the feel for a good draft — which means you lose the ability to tell a good AI draft from a plausible-but-hollow one. The verifier’s skill is the same skill as the doer’s skill. Let the doing atrophy and the verifying goes with it.
• Calibration drift. The whole assist model depends on you being good enough to catch the AI’s misses. The day you are no longer sharp enough to catch them, the verification gate is theater.

The defense is deliberate and a little old-fashioned: keep manual reps. Pilots hand-fly the plane periodically even though the autopilot could do it, precisely so they can still fly when it matters. Do the same. Some drafts, write cold. Some analyses, do by hand first and then compare to the AI. Keep the muscle you depend on to judge the machine. This is not nostalgia; it is the maintenance cost of staying in the loop where the judgment lives.

Coach’s Note — Here is the paradox at the center of this whole book: the better AI gets, the more your independent judgment matters, not less — because a more capable tool fails in more convincing ways, and only a sharp human catches a convincing failure. Outsource the typing all you like. Never outsource the competence that lets you tell when the typing is wrong.

15.8 — A Workplace Scenario, End to End

Abstract triage is easy to nod along to and hard to actually do. So let us run one all the way through. We ship a written scenario — code/workplace-scenario.txt — describing a real-shaped week in the working life of Maria Alvarez, an operations coordinator at a mid-size regional insurance agency. Open it now; read it before you read my analysis, and try your own pass first.

Maria’s recurring week, roughly, is: a Monday all-hands she must summarize and send; a stack of client emails to triage and answer; a monthly renewals report built from a messy spreadsheet; onboarding notes to write for each new hire; a quarterly vendor check-in she preps by skimming a long PDF; and — buried in all of it — client policy details that are legally protected.

Watch how the chapter’s machinery lands on it.

• Map (15.1). Five recurring tasks. The all-hands summary and the email triage are weekly and time-heavy. The renewals report is monthly but painful. Onboarding notes are per-hire and rule-shaped. The vendor check-in prep is quarterly — an hour spent skimming a long, non-confidential PDF. The protected client details thread through several of these.
• Triage (15.2). The all-hands summary, onboarding notes, and vendor check-in prep are assist-zone — rule-shaped, checkable, and (for the vendor PDF) long-document work with nothing confidential in it. Email triage is a blend: AI can draft replies, but Maria decides which client complaint gets escalated (judgment) and never lets a draft go without reading it. The renewals report is assist-zone for the formatting and first-pass summary — but only after the protected fields (client names, policy numbers) are stripped or the work stays inside the vetted tool — and the numbers get human verification against the source. And the protected client policy details are never-delegate/never-paste — Appendix C territory; those do not go into a consumer chatbot at all.
• Automate (15.3). The all-hands summary is the strongest automation candidate: recurring, rule-shaped, verifiable, bounded. It becomes a saved prompt template. Email triage becomes a drafting assist, not an automation — the escalation judgment keeps a human at the wheel.
• Choose models (15.4). Summarizing the meeting → a balanced everyday tier. Reasoning over the messy renewals spreadsheet → a stronger, long-context tier. Classifying a stack of routine emails → a cheap, fast tier. Three tiers, one week.
• Compose tools (15.5). Meeting tool → assistant for the summary → Maria verifies → email. The renewals report: spreadsheet → assistant for a draft narrative → Maria checks every figure → finished report. Verify at each seam.
• Measure (15.6). Baseline the all-hands summary at ~45 minutes; AI-enhanced with verification, ~15. Quality: fewer missed action items because the model is a tireless note-taker — if Maria still checks it against the transcript.
• Guard the skill (15.7). Maria still writes the occasional summary cold, so she stays sharp enough to catch the week the model quietly drops a decision.

That is the whole method on one professional’s real week: map, triage, automate the right pieces, pick the model per step, compose the tools, verify at the seams, measure, and protect both the confidential data and her own judgment. The scenario in code/workplace-scenario.txt is the one you will analyze for the graded lab — this section is your worked example, not your answer key. Yours must be your own analysis, in your own words, defending your own calls.

15.x — Interactive Lab: Workflow Mapper

Below this chapter on the website you will find an interactive panel called the Workflow Mapper. Go use it now — it is the rep that wires this whole chapter into your hands, and it is where the abstract triage from 15.2 becomes something you can see.

The Mapper lets you take one recurring task and break it into steps. For each step, you tag it: AI-step (the model drafts, generates, or accelerates) or human-verify step (you decide, check, or sign). As you build the sequence, the Mapper shows you the shape of your workflow — where AI is doing the leg-work and, crucially, whether there is a human-verify step standing between every AI-step and anything that ships. A workflow with two AI-steps in a row and no gate between them lights up as a risk, because that is exactly the pattern where an error travels un-caught. (Build 15.5’s meeting relay in it and the Mapper will flag the transcribe→summarize hand-off for exactly this reason — a flag that relay accepts on purpose, because nothing ships between those two steps and the human gate right after them checks every claim against the transcript itself.)

What it teaches is not one specific workflow — it is the felt sense of designing the human-in-the-loop deliberately instead of by accident. Build a real task from your own week. Then do the thing that matters: look at where you put the gates, and ask whether a mistake could get past them to a client, a patient, a decision, or a payroll run. Move a gate. Watch the risk change. That instinct — where does the verdict have to live? — is the entire chapter in one muscle.

Run it twice: once for a low-stakes task (a brainstorm) and once for a high-stakes one (anything with money, health, or a legal sign-off). Notice how many more gates the second one needs. That difference is your judgment calibrating itself.

Then build it for real — in BoodleBox. The Mapper is a design tool; BoodleBox is where the design becomes your actual week. Take the workflow you just mapped and stand it up on Concordia’s platform: a Folder for the task, the right bots @-mentioned at each AI-step, your reference files added with Attach Knowledge so answers stay grounded in your own documents, and a Box wherever a step is shared with a teammate — with your human-verify gates placed exactly where the Mapper told you they belong. No BoodleBox login? The same mapped workflow runs across the public free tools; you just wire the pieces by hand.

15.9 — Numbering Our Days

Now the week’s question, given its due. What does it mean to order our time and work well — to number our days?

“So teach us to number our days that we may get a heart of wisdom” (Psalm 90:12, ESV). Read the whole of Psalm 90 and you find Moses set this line against the shortness of a human life — “the years of our life are seventy, or even by reason of strength eighty” — and against the vastness of God, “from everlasting to everlasting.” Numbering our days is not morbid arithmetic. It is the discipline of holding our finitude honestly enough that we spend our hours on what is worth them. And notice what the numbering is for: not efficiency, not output — a heart of wisdom. The goal of ordering your time is not to do more. It is to become wise about what deserves the time you have.

This is the exact question an AI-enhanced workflow forces on you, whether you notice it or not. Every hour AI hands back to you is an hour you now have to spend on something. The tool answers “how” — how to draft faster, summarize quicker, format in seconds. It cannot answer “on what, and to what end.” That question is yours, and it is a question of wisdom, not speed. A person can use AI to become twice as fast at work that never mattered — and have simply hastened toward the wrong thing. Numbering your days is the refusal to let faster masquerade as better.

LCMS theology gives this a sturdy name: vocation. Your work is a calling through which God serves your neighbor — the client whose claim you process, the new hire you onboard, the colleague who reads your summary. Time is not yours to hoard or to fritter; it is entrusted, like the talents in the parable (Matthew 25:14–30), to be put faithfully to work. So an AI-enhanced workflow, rightly understood, is an act of stewardship: you order your time so the machine carries the mechanical load and you are freed for the parts of your calling that require a human heart — the hard conversation, the careful judgment, the neighbor who needs a person and not a chatbot. That is what the tool is for.

And here the spine rule and the psalm say the same thing from two directions. You own the verdict because the verdict — the wisdom, the accountable choice about what your finite hours serve — is precisely what cannot be delegated to a tool that does not know it will die. AI can help you number your tasks. Only a heart can number its days. Design your workflow so the machine handles the counting and you are left free for the wisdom.

15.10 — Common Pitfalls

Pitfall: Optimizing a task you should not be doing at all. Example: You build a slick AI workflow to generate a weekly report that, it turns out, three people read and none act on. Now you produce useless work faster. Fix: Map before you optimize (15.1). The first question is never “how do I speed this up?” It is “should this exist?” Kill or shrink the task before you automate it.

Pitfall: Pasting confidential or protected information into a consumer AI tool to “save time.” Example: To draft a reply faster, you paste a client’s full policy record — name, medical detail, account number — into a public chatbot. Fix: The never-delegate bucket is a hard line, not a convenience toggle. Know your org’s policy and the rules in Appendix C before you build the workflow, and design those steps to keep protected data out of public tools entirely.

Pitfall: Chaining AI steps with no human gate between them. Example: A meeting tool’s transcript feeds an AI summary that feeds an AI-drafted client email that sends — and a decision the meeting never actually made rides all the way to the client. Fix: Verify at the seam (15.5). Put a human-verify step between any AI-step and anything that ships. The Workflow Mapper flags exactly this pattern for a reason.

Pitfall: Running every step on the same model out of habit. Example: You use a frontier-tier model to reword one-line emails all day, then get a surprising bill; or you use the cheapest free model to analyze a dense contract and miss what it glossed over. Fix: Choose the model per step (15.4). Cheap and fast for simple/bulk; frontier for genuinely hard reasoning and long documents. Right-size to the step, not the project.

Pitfall: Measuring speed and ignoring quality. Example: You proudly cut report time in half, but two clients caught errors this month that the old slower process would have caught — a net loss you never counted. Fix: Measure both, always (15.6). Track revisions and errors-caught-later alongside the clock. Count verification time as part of the real cost. Faster-but-worse is a loss.

Pitfall: Letting the skill you rely on to verify quietly atrophy. Example: After a year of never drafting cold, you can no longer tell a strong analysis from a fluent-but-hollow one — so your “verification” is really just approval. Fix: Keep manual reps (15.7). Draft some things cold; do some analysis by hand first. The competence that lets you catch the AI is the one thing you cannot afford to outsource.

Pitfall: Confusing “assist” with “automate” and granting autonomy the verification can’t cover. Example: You promote a draft-and-send email task to run on a schedule with no read step, and a tone-deaf auto-reply goes to a grieving client. Fix: Move from assist to automate one notch at a time (15.3), and never past the point where you would fail to catch a bad result. Autonomy trails verification — always.

15.11 — Reps

The work is in the exercises. The keyboard is the gym; this is where Week 15 gets into your hands. This is a drill week, so the reps are substantial and they build straight toward the graded lab. A preview of what is waiting:

• Map your real week into the code/weekly-workflow-template.txt — every recurring task, its frequency, time, and shape.
• Triage every task into do-it-yourself / delegate-and-verify / never-delegate, and defend the hard calls.
• Find your automation opportunities by running the four-part test on your assist-zone tasks.
• Design one workflow end to end — steps, model per step, tools, verification gates, and a measure.
• Analyze the workplace scenario in code/workplace-scenario.txt the way we analyzed Maria’s week in 15.8.
• Measure a real before/after on one task, honestly, including verification time.

A short Check Your Reps quiz is embedded on this page, right under the chapter. Take it before you move on — five questions, grounded in exactly what you just read.

15.12 — This Week’s Lab

Because this is a drill week, there is no separate project file — the graded lab lives inside the exercises, in the section titled “Graded Lab — Your AI Week.” It merges the two halves of this chapter into one deliverable: you will design an AI-enhanced weekly workflow for your own real work and analyze the provided workplace scenario end to end, then measure one real result. It is graded out of 100 against a clear rubric, and it becomes your Canvas assignment for the week.

The lab is where map, triage, automate, model choice, tool composition, verification, and measurement stop being a chapter and become your practice. Do the reps first; they are the training that makes the lab doable in an evening.

15.13 — Coach’s Final Word

Here is what I want you to carry out of Week 15. For fourteen weeks you collected skills. This week you learned the thing that turns skills into a practice: you design where AI fits, on purpose, in writing — and you keep the verdict where the judgment lives. That design is the difference between a professional who has AI and one who works with it.

The method is small enough to hold in one hand. Map your week honestly. Triage every task into do-it-yourself, delegate-and-verify, or never-delegate. Automate only what is recurring, rule-shaped, verifiable, and bounded. Choose the model per step, not per habit. Compose the fewest tools that cover the legs, and verify at every seam. Measure both time saved and quality gained — honestly, with verification counted. And guard the skill you depend on to catch the machine, because a more capable tool fails in more convincing ways. Models will turn over weekly; half the version numbers in this chapter will be higher by the time you read it twice. The method will not.

And underneath the method, the psalm. Your days are numbered — finite, entrusted, worth more than the sum of your tasks. AI can give you hours back. It cannot tell you what they are for. That is the wisdom the tool cannot hold and the verdict you cannot delegate: what deserves the time you have? Order your work so the machine carries the counting and you are left free for the part that needs a heart. So teach us to number our days, that we may get a heart of wisdom.

Now go do the reps. The Workflow Mapper is waiting right below this page, the template and the scenario are in code/, and the graded lab is where it all comes together.

See you on Monday.

Up next: Read the exercises and do all of Week 15’s reps, then complete the graded lab inside it — Your AI Week. Pull tool choices from Appendix B, keep the never-paste rules from Appendix C in front of you, and check any unfamiliar term against Appendix D. Then Chapter 16 — The Future of Work: Capstone.