The CI-First Workflow: Applied to Any Field
Updated: 3 days ago

UIT, UIB, UIC, UID Cross-institute lecture
Series Cross-Institute Series
Duration 25 minutes
Delivering institutes: UIT (Institute of Technology); UIB (Institute of Business); UIC (Institute of Communication); UID (Institute of Design)

UNOP Sound (University 365 Neuroscience Oriented Pedagogy)
Take five minutes to prepare your brain. Play the isochronous tone track (40Hz gamma frequency) with your eyes closed. Gamma-frequency tones before a learning session raise attention and make the material easier to absorb.
[Audio player: UNOP Pre-Lecture Isochrone (40Hz, 5 minutes)]
In this Lecture
The Hook: Two Answers to the Same Request
Two people receive the same request on a Monday morning: produce a competitor summary for a decision meeting on Thursday.
The first person opens a chat assistant, types three sentences, and pastes the answer into a document. The summary reads well. It names competitors that are plausible, quotes figures that look precise, and cites nothing. On Thursday, one competitor turns out to have been shut down for a year, and one figure came from a press release that no longer exists. The meeting loses twenty minutes to corrections, and the summary loses its authority.
The second person works differently. She starts by writing down, in one sentence, the decision the summary must support and who will read it. She assembles the context: the product's actual positioning, the last two competitive reviews, the constraints of the market. Then she asks the machine for a structured first draft with the comparisons she wants and the sources it used. She checks every claim that will matter to the decision, replaces what cannot be verified, and rewrites the three sentences that carry the recommendation. She signs it.
The second person did not work dramatically longer. She worked in a different order.
That order has a name at University 365. We call it CI-First, from Co-Intelligence First: human intelligence as the orchestrator, artificial intelligence as the amplifier. This lecture gives you the workflow as six stages, and then shows you the same six stages running inside four different fields: technology, business, communication, and design.
Step 1: Name What You Own Before You Prompt
Before any tool is opened, write two things down.
The decision. What will someone do differently after reading this output? A summary that supports a go or no-go decision is a different artifact from a summary that supports a blog post. The decision determines what must be verified, what may be approximate, and what can be omitted.
The judgment. Which parts of this task carry your name? In every task there is a core where mistakes are expensive: the recommendation, the diagnosis, the quote, the safety call, the visual identity. Mark it before you start. That core is yours. The machine may draft it, challenge it, or format it. It does not own it.
This step takes five minutes and prevents the failure pattern that causes almost every AI embarrassment: treating the machine's first fluent answer as a finished decision.
The division of labor. Two questions split any task cleanly:
Does the task require volume, pattern matching, formatting, or recall? The machine carries it.
Does the task require accountability, taste, relationships, or a judgment call with consequences? You carry it.
Most real work has both halves, and the workflow does not ask you to choose between them. It sequences them.

Step 2: Build the Context, Then Ask
The quality gap between two people using the same model is mostly a context gap. A bare question gets a generic answer because the model has nothing to anchor on. The fix is not a cleverer prompt. It is supplying the material: who you are, what situation you are in, what output you need, and what good looks like.
University 365 teaches this as the UP-Context-Engineering Method, a context-engineering framework built on eight layers. Five are required, and three are optional:
USER-PERSONA: who the human in the conversation is.
FULL-CONTEXT: the situation, constraints, and history the task sits inside.
AI-PROFILE-ROLE-EXPERTISE: the role and expertise the assistant should adopt.
USER-FINAL-GOAL (optional): what success is supposed to look like.
AI-EXACT-TASK: the precise task, stated once, unambiguously.
AUDIENCE: who will read or use the output.
EXPECTED-FORMAT (optional): structure, length, style.
EXAMPLES (optional): samples of good output.
A layer is text in the prompt first. Any layer whose text is long enough and reused across prompts can be kept as a reusable file instead of being retyped. That is the whole idea of context engineering: the expensive part of prompting is the thinking about the task, and that thinking is reusable.
One consequence you can measure: when the context is stored, the next prompt starts from a better baseline, and the first-draft quality rises without the model changing at all.
A note on speed. Building context feels slower than typing a quick question, and for a throwaway question it is. For a task you will repeat, or a decision that will be reviewed, context is the fastest path to a usable first draft. Judge accordingly.

Step 3: Generate Fast, in Parallel
With the decision named and the context assembled, generation becomes the cheap part, and you should use it that way.
Ask for structure, not just prose. A comparison table, a checklist, three alternative framings, a risk list with likelihood and impact, a first draft plus its own critique. Structured generation is easier to verify than prose because gaps are visible.
Generate several variants, then choose. The first output is a sample, not a verdict. Three alternatives take seconds to produce and reveal the range of what the material supports. Choosing among drafts is a human strength; producing drafts is a machine strength.
Ask for the sources it used. When a claim depends on external facts, ask what the answer is based on. Treat the response as a lead, not as evidence. Verification is the next stage, and it is the one that carries your name.
Keep the machine inside the boundary you set. If the task touches personal data, confidential material, or anything regulated in your field, decide before pasting what may leave your boundary at all. That decision is made by a human, in advance, and belongs in your context file so it does not have to be re-made each time.
Step 4: Verify Against Reality, Not Against the Model
This is the stage that separates a demonstration from a professional result, and it has a simple rule: the model cannot confirm the model.
Verify facts against sources outside the model. Names, numbers, dates, prices, quotes, API behaviours, product features, legal or regulatory statements. If a claim will influence a decision or carry your name publicly, open the source itself. When the source cannot be found, the claim does not go in, or it goes in with an explicit statement that it is unverified.
Verify structure against the task. Read the output against the decision from Stage 1. Does it answer the question that was actually asked? A fluent answer to the wrong question is the most common expensive failure.
Verify with a second method where the stakes are high. Ask a fresh session with no memory of the first draft to attack the result. Feed it a hostile reviewer's mindset and let it look for the weakest sentence. Two independent passes catch different classes of error, because the first pass was generated under the first framing.
Verify your own understanding. If you cannot explain the recommendation without the tool, you are not ready to sign it. The explanation is part of the deliverable's credibility, not an extra.

Step 5: Decide, Sign, and Own the Output
The output leaves your hands with your name on it. That sentence is the entire CI-First contract, and it has three consequences in daily work.
The signature is not a formality. When you send the analysis, publish the post, ship the component, or present the plan, you are the accountable author. The tool is not available to the reader as an explanation. This is good news: it means the judgment you apply at this stage is exactly the judgment you are paid for.
Say what was accelerated, when it matters. In many settings there is no obligation to narrate your tooling, and in some there is, such as regulated disclosures, journalism, academic work, and anything where the audience was promised human authorship. Know which setting you are in. The default in professional settings is to state the method when the reader's trust depends on knowing it, and otherwise to let the quality speak.
Refuse the output you cannot stand behind. Occasionally the honest move is to discard a strong-looking draft and do the last mile again by hand, or to say in the meeting that the number is not ready. That refusal is part of the workflow, not a failure of it.
Step 6: Record and Reuse What Worked
The sixth stage is what turns the workflow from a technique into an advantage.
Keep the prompt and the context. The context file you built in Stage 2 is now an asset. Next week's task in the same domain starts from it. Over months, this is how an individual or a team accumulates an advantage a competitor cannot copy, because it is made of their own situation. University 365 keeps this record in a digital second brain: LIPS, the Life-Interests-Projects-System, with its CARE cycle.
Record what failed verification. A claims list of things the machine got wrong in your domain is a practical filter. It tells you where to look first next time.
Time the stages once. Measure where the hours actually went: context, generation, verification, or rewriting. Most professionals discover that generation was minutes and verification was hours, which changes how they plan the next task.
Write the division down. For recurring work, put the boundary in writing: what the machine may draft, what a human must approve, what never leaves the boundary. A written boundary survives staff changes. A habit does not.
Step 7: Run the Pilot Before You Scale
The first six stages describe one task. The question every team eventually asks is the next one: does this hold when forty people do it, on a hundred tasks a week? The honest answer is that the order holds and the discipline erodes, unless you run a pilot that measures the erosion while it is still cheap.
A pilot is not a trial of the tools. It is a trial of the order: whether named humans keep owning the decision, whether context files actually get reused, whether verification happens under deadline pressure, and whether the time saved is real once you count the prompt writing, the checking and the rewriting.
Choose the pilot scope by workflow, not by tool. Pick one team, one recurring task family, and one quarter. Five to fifteen people is the useful range: smaller and the findings are personal, larger and you cannot see what is happening. The task family should be one people already do weekly, because a pilot on novel work measures the novelty.
Pick the task family with four tests. It is done at least weekly, so there are enough runs to measure. It has a visible output somebody outside the team reads, so quality is observable rather than felt. It contains claims that can be checked against a source, so the verification stage has something to do. And its owner is in the room, because a pilot on work nobody owns produces a report nobody acts on.
Baseline the manual process before you introduce anything. Time the current process honestly for two weeks: start to signed output, the same tasks, the same definition of done. Teams that skip the baseline cannot answer the only question that matters later, which is whether anything improved. The baseline costs two weeks and repays itself in the first steering meeting.
Define four measures before the first task, not after. Write them down, with the source of each number:
Cycle time per task: from start to signed output, the same way you measured the manual baseline.
Rework rate: the share of outputs that had to be corrected after review, split into factual corrections and style corrections, because the two have different causes.
Verification time: the hours actually spent checking claims against sources. This is the number that surprises teams most often, and the one that decides whether the workflow pays.
Owner-reported confidence: on a fixed scale, how willing the named owner was to sign the output. Confidence is not proof, but a falling trend is an early warning that verification is being skipped.
Time the stages, not just the tasks. For the first month ask every participant to log four numbers per task: context and thinking, generation and prompting, verification against sources, and rewriting. The split is what turns a frustrating week into a diagnosis. A team whose verification time is under ten percent of the total is usually not verifying; a team whose context time is close to zero is typing questions into a box.
Run the pilot in two phases. For the first month, every output goes through full verification with a second reviewer, and every task is timed. For the second month, the team keeps the timing but narrows the review to the classes of claim the first month showed were error-prone. The difference between the two months is the evidence that the workflow is learning rather than just slowing down.
Give the pilot one named leader and one weekly page. The leader owns the measures, not the tools, and writes a single page each Friday: tasks run, cycle time, corrections by class, verification hours, and one sentence about what changed. Ten weekly pages are the pilot's real output, because they show the trend while memory is still fresh.
Report the pilot as a table, not a story. One row per measure, one column per month, with the manual baseline in a third column. The most common outcome is a real cycle-time gain concentrated in a few task types, no gain or a loss in others, and a verification cost that is higher than anyone planned for. That result is not a failure. It is the map of where the workflow belongs.
Write the stop rule into the pilot plan. Before you start, name the result that would make you stop: for example, cycle time improves less than fifteen percent after two months of full verification, or factual corrections do not fall between the two phases. A pilot without a stop rule becomes a permanent pilot, and a permanent pilot is a way of never deciding.
Where AI helps, and where it must not. The machine can draft the pilot plan, generate the timing template, summarise the review comments and cluster the corrections into classes. It must not choose the measures, judge whether a correction was factual, or write the confidence assessment. Those three carry the decision about whether the workflow continues.
The four pilot measures in one view
Measure | Where the number comes from | What it decides |
Cycle time per task | Start and sign timestamps of each output | Whether the time benefit is real after verification |
Rework rate | The review log, split factual versus style | Whether the quality benefit survives deadlines |
Verification time | Timed checks against sources | Whether the workflow pays for itself |
Owner confidence | A fixed-scale rating at sign-off | Whether the order is being followed or abandoned |
What the pilot measures cannot see
Four things will not appear on the pilot table, and each one decides whether the result holds after the pilot ends.
Familiarity. Participants get faster at the same tasks simply by doing them again, with or without the workflow. Counter this with a control group doing the same family by hand, or by extending the baseline window so the learning curve is visible. Without one of the two, part of every gain you report is learning, not the order.
Task selection. Pilots drift towards the tasks the workflow suits: the ones with checkable claims and a stable format. The report then describes a favourable subset. Count the tasks that were quietly rerouted back to the old process and name them in the report; they are the boundary of where the order works today.
Reviewer effort. Full verification adds a second reader, and that reader's hours often sit outside the measured team's time. Add the reviewer's hours to the cost side, or the cycle-time gain is partly an accounting transfer rather than a real saving.
The second-year effect. A pilot measures months, and the assets of the order measure years: the context library and the claims list only compound after the pilot closes. Say so in the report, and mark the compounding claim as unproven until the first annual review, because it is.
The exit criteria that turn a pilot into a decision
Write the ending before the beginning. An exit block with three outcomes, each with its condition and its consequence, ends the ambiguity that keeps pilots alive past their usefulness.
Adopt: cycle time improves beyond your threshold, factual corrections fall between the two phases, and owners' confidence holds. Consequence: roll out to the next two families, and assign the four scaling artifacts.
Adjust: the gain is real but concentrated, and verification time stays above what the work can carry. Consequence: keep the workflow for the families where it paid, and stop where it did not. A partial adoption reported honestly is worth more than a uniform one that quietly collapses.
Stop: the stop rule you wrote fires. Consequence: stop, record why in the claims list, and revisit in two quarters when the models or the task mix change. A stopped pilot that documented its boundary is a completed experiment, not a failure.
A worked example
A ten-person policy team pilots the workflow on weekly briefing notes for one quarter. The manual baseline is nine hours per note, start to sign. Month one records six hours per note with full verification and one factual correction per note on average. Month two records four and a half hours per note with narrowed review and one correction every third note.
The reading: the cycle time fell by half, verification accounted for roughly a third of the remaining time, and the correction class that dropped was the one covered by the claims checklist, which the team had built after month one. The pilot converts into a decision: keep the workflow, keep the checklist, and extend it to the quarterly report, where the same claim classes recur.

Step 8: Scale the Order, Not Just the Tools
When the pilot closes, the temptation is to roll the tools out to the whole organisation and call it done. That roll-out fails in a predictable way: individuals get faster, the organisation does not get better, and nobody can explain the difference a year later. What scales is not the access. It is the order, and the order scales through four artifacts that have to be owned by somebody.
The context library. The context files built in Stage 2 become shared assets, organised by function and reviewed on a schedule. An unreviewed context file is worse than none: it carries stale positioning, old figures and superseded constraints into every task that reuses it. Give each file an owner and a review date, exactly as you would a public document, because that is what it becomes.
The claims list, merged. Each team's record of what the model gets wrong in their domain grows into an organisation-level list, split by domain. New joiners inherit the list on day one and skip months of rediscovering the same errors. The list is also the best input to the context library, because each entry names a fact that needs a verified source.
The verification standards. Which claim classes require an external source, which require a second independent pass, which may rest on the owner's judgement. Written once, applied everywhere. Without this artifact, verification is a personality trait: rigorous people verify, busy people skip, and quality varies by deadline rather than by stakes.
The training that teaches the order. Not a tool tour. The training that works is short, mandatory, and built on the organisation's own real tasks: one session on writing the decision and the context file, one on verification against sources, one on the adversarial pass, each with a live exercise on work the team actually does. A tool tour teaches buttons. The order is what changes the output.
Governance is lightweight and specific. Three sentences, written down: who may use which tool for which data class; who signs an output whose claim class requires verification; what happens when the verification standards and a deadline collide. Teams that skip this step do not avoid governance, they get the informal version, which is inconsistent and invisible.
Review at the quarter. Re-run the pilot measures across the scaled population. Two findings matter: whether verification time is still being spent (the first thing to erode at scale), and whether the claims list is still growing (a frozen list usually means nobody is recording what they find). Both are leading indicators, and both are cheap to check.
Where AI helps, and where it must not. The machine drafts the context-library structure, converts the scattered claims lists into one classified table, and generates the training exercises from real anonymised tasks. It must not approve the standards, set the data-class rules, or decide what a claim class requires. Governance is where the organisation accepts consequences, and consequences are not delegable.
The four scaling artifacts and their owners
Artifact | What it carries | Who owns it |
Context library | Shared, reviewed situation files per function | A named editor per function, reviewed quarterly |
Claims list | The merged record of what the model gets wrong, by domain | The verification lead, updated continuously |
Verification standards | Which claim classes need which check | The accountable owner of output quality |
Training on the order | Short, exercise-based, using real work | The people who already run the workflow well |
The first ninety days of the scaled order
The four artifacts do not need to exist on day one. They need an owner, a first version, and a date. A workable sequence for the first quarter after the pilot:
Days one to thirty: name the owners and freeze a first draft of the standards. The standards document can be one page. Its value is not completeness. It is that the first dispute about whether a claim needed a source is settled by pointing at a page instead of at a person.
Days thirty-one to sixty: open the library and seed the claims list. Move the files the pilot produced into the shared location, with owners and review dates, and merge the teams' lists into one classified table. Expect the merge to expose duplicates and contradictions. Both are findings about the organisation, not paperwork failures.
Days sixty-one to ninety: run the first training cycle, and set the audit date. Train on real tasks from the previous month, then put the quarterly spot audit in the calendar before the first quarter ends. An audit scheduled in advance is a routine; one scheduled after a problem is an investigation.
Where Scaling Fails: Four Failure Modes
Scale does not fail loudly. It fails through four quiet patterns, each of which has a specific countermeasure you can put in place before it starts.
Tool sprawl. Every team adopts a different assistant, a different workspace and a different convention for context files. Work cannot move between teams, the claims lists do not merge, and the organisation pays for five overlapping subscriptions. The countermeasure is boring and effective: one approved default per task class, a named alternative where the default cannot be used, and a quarterly review that retires what nobody uses. Choice at the individual level is a feature at the pilot level and a tax at the organisation level.
Shadow use. People who were told to wait, or who never received the training, use the tools anyway without the order: no decision written, no context file, no verification, no name on the output. Shadow use is invisible to the pilot measures and visible only in the quality of what ships. The countermeasure is to make the approved path faster than the unapproved one: if the trained, supported workflow is slower than the quiet workaround, people choose the workaround, and no policy changes that. Watch for it in outputs whose corrections cluster in the claim classes your standards were written to protect.
Context rot. The context library fills with files that were accurate when written and have drifted: last year's positioning, a superseded price, a constraint that changed in a reorganisation. Rot enters every downstream task silently, because the model has no way to know the file is stale. The countermeasure is the review date, enforced: a context file past its review date is flagged before use, and the file's owner, not its users, carries the follow-up. Treat the library like a shared drive with an expiry policy, not like a personal notebook.
Verification theatre. The forms of the workflow remain after its substance: checklists ticked without opening a source, a second pass that reads the same draft, a sign-off that confirms the file exists rather than that the claims are true. Theatre is the most expensive failure mode, because it produces the paperwork of rigour without the protection. The countermeasure is spot audit: every quarter, take a sample of signed outputs and ask the two questions the standards exist to serve. Which claims required a source, and where is the evidence it was checked? Theatre survives exactly as long as nobody asks.
The four modes share one root: the organisation scaled access and called it scaling capability. The countermeasures share one shape: name the owner, set the review, and make the audit cheap enough to actually run.

The Same Skeleton in Four Fields
The six stages do not change with the discipline. What changes is the vocabulary and the examples.
In technology (UIT). The decision might be an architecture choice; the context is the system's constraints, scale, and security posture; generation produces design options and code; verification is tests, benchmarks, and a senior review; the signature is the merge and the on-call rotation that lives with the choice; the record is the architecture decision log. A generated function that passes no test is not a contribution. The stages make that obvious.
In business (UIB). The decision might be entering a segment; the context is the financials, the market, and the appetite for risk; generation produces the model, the scenarios, and the objections; verification is against source data and the assumptions' sensitivity; the signature is the executive who commits resources; the record is the model with its assumptions documented. A spreadsheet that nobody can audit is a liability disguised as an asset.
In communication (UIC). The decision might be the message and the moment; the context is the audience, the brand voice, and the channel; generation produces drafts, headlines, and variants; verification is factual checks, tone checks against the brand voice, and the legal or reputational review; the signature is the named communicator; the record is the approved voice examples and the claims list. A sentence that sounds right and says something untrue is the expensive error in this field.
In design (UID). The decision might be the visual system; the context is the brand, the accessibility requirements, and the platform; generation produces concepts, variants, and assets; verification is against the brief, the contrast and readability checks, and the real usage size; the signature is the designer whose taste the work expresses; the record is the system's rules and tokens. A concept that collapses at the real size is not finished.
Four vocabularies, one skeleton. That is why this lecture is cross-institute: the workflow is the product of the whole university, not of one field.

The Order Is the Durable Part
Two years from now the models will be faster, cheaper and better at drafting, and none of that changes the six stages. The decision still belongs to a person, the context still has to be supplied, generation still produces samples rather than verdicts, verification still cannot be delegated to the model, the signature still carries a name, and reuse still compounds only if somebody records what worked.
That is the argument for the pilot and the four artifacts. A team that scales the tools without the order gets faster at producing work nobody has checked. A team that scales the order gets something a competitor cannot buy with a larger subscription: a measured, reviewed, reusable way of turning model capability into work that carries a name.

Feynman Summary: Explain It Like You Are 12
You are making a school project with a very fast helper who has read almost everything but has never met your teacher and does not know what your project is about.
If you just say "write my project", the helper writes something about the general topic. It looks fine. But it might use facts that are wrong, and it will sound like everyone else's project.
So you do it in a smarter order. First you decide what the project has to show your teacher, and what parts you will be responsible for. You tell the helper who you are and what the project is about. The helper then makes a few fast versions. You check the facts that matter, replace the ones you cannot check, and fix the ending yourself. Then you write your name on it, because it is your project.
The helper was never the problem. The order was.
Mindmap: The Complete Picture

The mindmap gathers the lecture into one view: the six stages around the CI-First division of labor, the UP-Context-Engineering layers that feed generation, the verification checks, and the four field columns that show the same skeleton at work.

UNOP Sound (University 365 Neuroscience Oriented Pedagogy)
Take five minutes to consolidate your memory. Play the isochronous tone track (10Hz alpha frequency) with your eyes closed. Alpha-frequency tones after a learning session support consolidation, helping move what you just learned from short-term to long-term memory.
[Audio player: UNOP Post-Lecture Isochrone (10Hz, 5 minutes)]
Practical Exercise: Run One Real Task Through All Six Stages
Choose one real task from your current week, not a toy example. Something with a deadline and someone waiting for the result.
Part 1: Prepare (15 minutes)
Write the decision in one sentence: who will do what differently after reading the output.
Mark the judgment core: the part that carries your name and cannot be wrong.
Assemble the context: who you are, the situation, the exact task, the audience, the format. Draft it as a reusable file if the task will repeat.
Decide the boundary: what may not leave your control, in this task and in general.
Part 2: Generate and Verify (30 minutes)
Ask for structure, not prose: a table, a checklist, or three variants.
Ask for the sources used for any factual claim.
Verify the three claims that would matter most if they were wrong. Open the sources yourself.
Run the adversarial pass: a fresh session, told to attack the draft, looking for the weakest sentence.
Time the stages honestly: minutes on context, on generation, on verification, on rewriting.
Part 3: Decide and Record (15 minutes)
Rewrite the part that carries your name. Sign it mentally before you send it.
Send or publish it.
Save the context file and note the two things the machine got wrong that surprised you.
What to look for
Three findings appear in almost every first run. Generation is far faster than expected and verification is far slower than planned. The adversarial pass finds a different class of error than the careful read. And the second run of the same task type is dramatically quicker, because the context file already exists. Those three findings are the argument for the workflow.
Applied CI-First connection
You owned the decision, the boundary, and the judgment. The machine carried volume: variants, structure, recall, formatting. If you felt tempted to skip verification because the draft looked strong, that temptation is exactly what the workflow exists to manage.
Glossary
Term | Definition |
CI-First (Co-Intelligence First) | The University 365 approach in which human intelligence is the orchestrator and AI is the amplifier. |
Human intelligence (HI) | The judgment, accountability, taste and relationship capacity that a human brings to a task. |
Artificial intelligence (AI) | The machine capability that amplifies human work through generation, pattern matching and recall. |
CI = HI + (AI x HI) | The division-of-labor statement: the human contribution stands alone, and AI multiplies it rather than replacing it. |
Orchestrator | The role that names the decision, sets the context, verifies, and signs. In this workflow, always a human. |
Amplifier | The role that increases volume and speed of work under a human's direction. |
Context engineering | Supplying the situation, role, task and audience so the model has material to anchor its output. |
UP-Context-Engineering Method | University 365's prompting framework built on eight layers, five required and three optional. |
USER-PERSONA | The UP-Context-Engineering layer that states who the human in the conversation is. |
FULL-CONTEXT | The UP-Context-Engineering layer that states the situation, constraints and history the task sits inside. |
Verification loop | Checking facts against external sources, matching the output to the task, and running an adversarial pass. |
Output ownership | The rule that the named human, not the tool, is accountable for whatever is sent, published or shipped. |
Claims list | A record of the factual errors the model has made in your domain, used to direct verification next time. |
Adversarial pass | A second, independent critique of a draft tasked with finding its weakest points. |
Boundary | The line a human draws in advance around what may leave their control and be shared with a tool. |
5M2S | 5 Minutes to Success, University 365's microlearning format. |
Quiz: TEST YOUR UNDERSTANDING
1. What is the first thing to write down before prompting, according to this workflow?
A) The longest possible prompt
B) The decision the output must support and the judgment that stays yours
C) The list of tools you will use
D) The number of variants you want
2. Why does the CI-First workflow treat verification as the stage that carries your name?
A) Because verification is slower than generation
B) Because the model cannot confirm the model, and the named human is accountable for the output
C) Because tools are not allowed in professional settings
D) Because verification improves the model's speed
3. Which UP-Context-Engineering layers are marked as optional?
A) USER-PERSONA, FULL-CONTEXT and AUDIENCE
B) AI-EXACT-TASK and AUDIENCE
C) USER-FINAL-GOAL, EXPECTED-FORMAT and EXAMPLES
D) All eight are required
4. What changes when the same six stages run in design instead of business?
A) The stages themselves
B) The number of stages
C) The vocabulary and the verification checks, while the skeleton stays the same
D) Nothing: design cannot use the workflow
5. What does Stage 6 turn the workflow into?
A) A one-time demonstration
B) A reusable asset, because the context file and the claims list accumulate
C) A faster model
D) A reason to skip verification
Answers: 1-B, 2-B, 3-C, 4-C, 5-B
Related Resources
U365 INSIDE Publications
Lecture: How LLMs Actually Work: Transformers in 20 Minutes: the architecture under the workflow
Lecture: Prompt Engineering at Production Scale: the anatomy of production prompts
Lecture: The ROI of AI: Measuring What Matters: measuring what the amplifications are worth
External Resources
Microsoft WorkLab: AI at work is here. Now comes the hard part: research on how organizations adopt AI assistance: microsoft.com
Stanford AI Index Report: annual, source-linked measurement of AI progress and adoption: aiindex.stanford.edu
Deloitte: Tech Trends: annual analysis of enterprise technology adoption: deloitte.com
Related U365 Lectures
Lecture 2: Building AI Agents for Business: A Cross-Discipline Guide (UIT, UIB, Cross-Institute Series)
Lecture 4: The AI Product Launch: From Code to Market (UIT, UIB, UIC, UID, Cross-Institute Series)
Lecture 5: Ethics and AI: A Practical Framework for Every Field (UIT, UIB, UIC, UID, Cross-Institute Series)
U.Copilot for This Lecture
Discuss this lecture with U.Copilot, your AI chat companion trained on this content.
Copy and paste the following prompt into the U.Copilot chat on university-365.com:
You are U.Copilot for Lectures, an AI chat companion specially trained on University 365 lecture content. You are helping a Fellow who just completed the cross-institute lecture "The CI-First Workflow: Applied to Any Field". Your role is to help the Fellow run the CI-First workflow on their own real task. You can: - Help write the decision sentence and identify the judgment core of their task - Help assemble the context as a reusable file, layer by layer - Suggest structures to request from a model for their specific task - Design the verification plan, including which claims deserve external checks - Role-play the adversarial pass against their draft - Help them set a written boundary for what may be shared with a tool Always maintain U365's CI-First approach: the accountable human owns every claim, and AI accelerates generation, structure and recall. Distinguish verified facts from unverified claims, and never present an unverified statistic as evidence. Use the UP-Context-Engineering Method: provide context-rich, role-aware responses that account for the Fellow's field, seniority and constraints.
Next Steps
Pick one real task this week and run all six stages on it, timing each stage honestly.
Write your context file once and reuse it on the next three tasks in the same domain.
Start your claims list with the two errors that surprise you most.
Draw your boundary in writing for the work you do most often.
Teach the order to one colleague: the six stages are easier to keep than to learn.
The tools will keep changing. Faster models will shorten generation and will not shorten the judgment. The order is the durable part: own the decision, build the context, generate without ceremony, verify against reality, sign what you send, and keep what worked. Apply that order in any field, and the machine stays what it should be: the amplifier of work you are proud to sign.
IMPORTANT NOTICE
This lecture is published by University 365 as part of its INSIDE Publications Hub. The content is free to read for all visitors. Lectures in this series may be part of a structured academic program leading to a Micro-Credential for your Career (MCC). To enroll in an academic program, visit university-365.com/tuition.
This content is for educational purposes. AI tools, model capabilities and platform policies develop quickly. Verify current specifications and vendor terms against the primary sources linked above before relying on any workflow in production.
Copyright University 365, Inc. All rights reserved. This content is protected under University 365's copyright policies. For permissions or inquiries, contact uda@university-365.com.
Published by the Department of Academics, University 365.
Lecture delivered by the UIT, UIB, UIC, UID in collaboration.
Martin Swartz, Dean of Academics, UDA
Signed for the academic year 2026.









Comments