AI Adoption Level Guide

LOOKING FOR USE CASES

Chat: Get advice.

Docs: Get personalized consumables.

Work: AI completes tasks for you to modify.

Auto: AI systems get work done for you.

Grow: AI builds systems driving outcomes across teams.

• “I’m refining my prompts & use cases, generally getting familiar.” (nearing-completion of L0)
• “AI sounds interesting, but I don’t know how I’d use it.”
• “I’m not opposed to AI, but I have major concerns about it replacing human jobs, which is why I haven’t used it.”
• “I’ve heard stories of AI getting things wrong, so I’ll be eager to use it when it has improved.”

• “I’ve integrated AI and automation into my daily work, and I’m experimenting with X tools that have led to Y results.” (nearing-completion of L1)
• “I often use ChatGPT to help me research topics more efficiently — it consistently saves me time.”
• “It’s hard to trust what AI produces without intervention. Sometimes it’s so dumb.”

• “I regularly use AI to analyze X… it speeds up analysis but can miss nuances, so I’m refining the process.” (nearing-completion of L2)
• “AI isn’t a product, and not exactly a feature — it’s a coworker.”
• “We have a shared infrastructure, a company OS for shared knowledge where 1 learning immediately gets deployed to the whole team.”
• (As a bar-raiser) “We don’t hire below the team’s median AI level anymore — new hires expected at LN within 90 days.”

• “I introduced AI tools & workflows across my team — we now save 10+ hours per week & quality went up.” (nearing-completion of L3)
• “I have AI doing work for me. The tedious stuff is taken care of so I can focus on high-leverage work.”
• Teammates don’t need to ask “can you make that one for me too?” — the skill is documented & marked approved/beta in the shared library.

• “My job is no longer to create outputs. The job is to build & refine the system to create outputs I don’t need to touch.” (nearing-completion of L4)
• “Agents run in the background, autonomously. Even when I’m OOO. We fine-tune the skills we already figured out so they just run.”
• Software is cheap & personal. You ship the tool your team needs this week — in production by Thursday.

• Company-as-a-product frame: departments are features; AI inherits dept KPIs, no separate metrics.
• “Across teams, things just run — AI auto-flags & repairs gaps toward our goals before I see them.”
• “Your org-wide blackbelt means you’ve shifted almost exclusively from ‘How’ to the human judgement of ‘Why’ — toward transforming life outcomes.”

• AI hasn’t had a meaningful impact on real work (may not have used a chat AI tool).
• Workflow unchanged from pre-AI: types question, reads answer, goes back to working as before.
• “Reflects limited exposure, not lack of ability.”
• Discovering what AI is good at AND where its limits are.

• Output looks about the same as pre-AI, but faster to first draft.
• Posture: on-purpose user. Curious, willing to experiment, but not too deep yet.
• Purposeful use of one or more AI tools; can explain why AI was used.
• Primarily used for creating summaries, paraphrases, & strengthening ideas.
• Generic responses or re-explaining context every session.
• A few chat tabs; maybe a system prompt.
• Repeatable systems may not be necessarily obvious, but AI is used more consistently across similar tasks.

• Regular, repeatable AI usage with clear impact; multiple tools / AI-enhanced workflows.
• Key functions, workflows, and context is identified with SOPs built around them & converting into AI systems.
• No more copy-paste context: the AI reads your real tools directly & company brain is queryable. Context flows from real systems.
• Anyone can ask a question and get an answer rooted in the org’s actual state. A new hire has the same company context as a multi-year vet.
• AI org-adoption is spread bottom up / inside out from team champions demonstrating what’s possible. (Top-down with no adoption gets stale context & bad outputs.) Adoption is treated as internal marketing: shared wins, named users, repeatable stories.
• First governance moves land here — credentialed connectors (not personal accounts), endpoint-level read/write restrictions on sensitive systems, an auditable trail of what AI touched. Safety scales the adoption; it doesn’t slow it.

• Prompt Library upgraded to a Skill Library. The team reaches for repeatable AI workflows (skills, commands, prompts) & gets consistent outputs.
• Teammates rely on the things you ship; humans hit approve more often than author.
• “Augmentation layer” — Hours of tedious work is offloaded, even upgraded with an AI workflow; people now spend time on high-leverage work.
• The team’s shared skills are treated as mini-products with iteration cycles, new releases & pruning.
• Individual virtuosity that doesn’t spread influence to others doesn’t compound.
• “AI-native” as discrete phase shift, not continuous climb — the team didn’t wait for AI to happen to them.
• Guardrails are productized — scoped permissions per skill, PII filtering, & a queryable audit trail let the team ship faster, not slower. “If it’s safe enough for the most-regulated function, it’s safe enough for anywhere.”

• Introduces AI across teams; leads initiatives with measurable impact.
• Top Hi-ICs have created agents, workflows, & evals to replace themselves.
• “Autonomous layer” — Work happens without a human in the loop on the happy path.
• Scheduled jobs and event-driven agents running on top of L2–L3 skills + knowledge.
• Rethink-the-work zone: Stop shipping tools. Start shipping systems that change how the function operates.
• The tool nobody will rebuild is the one that runs forever.
• “System Builder” — complex multi-phase skills that chain; subagents; quality-gate checks.
• “Context-switching” — moved from single-session tab-switching between AI and context tools (now in one place) into objectives between sessions.
• Retire-rate metric: how often you delete a tool that didn’t earn its keep. >0 means you’re shipping for need, not theater.

• The best managers are the top AI users (even if they have no direct reports). Your Ceiling is unhindered by Who or How, but is tied to your ability to lead. The compounding skill loop is: Vision, Direct, Review, Decide.
• Agents coordinate across departments; the system runs the company while humans set direction.
• “Product layer” — internal autonomous capabilities turn into a company’s product motion.
• KPI toward 24/7 agent uptime. Minimize gaps, outages, etc. even for nights, weekends, holidays, & employee PTO.
• Company-wide value of “Building the robot” where AI experimentation & systems building have baseline thresholds for hiring & performance reviews.

• Less than weekly exchange.

• Daily exchange.

• AI is the first tool opened when starting a task.

• Multiple models used daily by use case.

• 70/30 refining systems vs the outputs they produce.

• Full-time system refinement.

• Usage Metrics (Frequency & Trust)

• Time Saved

• Quality Metrics (Error Rates, rework)

• Workflow Metrics (Cycle time, Throughput)

• Financial Metrics (Cost, Revenue)

• 24/7 agent uptime

• Used a major chat AI tool for a real work task AND kept an output that beat what you’d have written alone.

• Personal OS: You have a functional system that compounds knowledge & personal learnings for better outputs. e.g. you have committed a persistent-context file (CLAUDE.md, a saved Project, a Copilot agent instruction, or equivalent) that the AI reads on every session, AND you can name one output in the last 14 days that was measurably better because that context was loaded, AND AI is connected to at least one real work system (M365, Google Drive, Slack, Snowflake, the CRM) so it can reach your actual work instead of only what you paste in.

• Team OS: Someone other than you organically pulled context from the shared knowledge base into their own output within hours or days of you adding it — without being told the context was there. (Example: you save a customer-win transcript; tomorrow a teammate creating a deck pulls a silver-bullet testimony unprompted, and the deck closes a deal.)

• Function OS: 3+ shared skills/templates teammates reach for unprompted AND ≥1 workflow chains two tools end-to-end (no copy-paste in the middle).
• ≥1 skill/agent on a schedule or trigger, ran ≥7 days unattended AND ≥1 bespoke internal app/dashboard built primarily by AI.
• AND you can name those 3 skills aloud — if you can’t name them, they’re a drift risk and not consciously adopted.
• The test isn’t skill count — it’s whether teammates reach for them without thinking.

• Agent OS: Shipping for outcomes, not just features — shipped a system felt by ≥2 functions outside your own AND stopped touching outputs on ≥1 major workflow (you only touch the system).

• Company OS: You took ≥5 consecutive workdays off (real OOO, no Slack) AND on return your cross-team systems had advanced goal-progress with no rollback, no fire-fighting, AND at least one system had self-updated its own context or eval threshold without you.
• “Revenue per Employee / Members served per FTE is skyrocketing because output goes up without headcount.”

• 10 min · Start with low-risk tasks for firsthand experience. Open Claude, ChatGPT, or Perplexity instead of Google — ask one question (e.g. explain something from a recent meeting) while waiting for something, and probe with followups.

• 10 min · Write a 1-paragraph “who I am / how I want responses” and save it where the AI reads it every session (CLAUDE.md, a Claude Project, a Copilot agent instruction, a Gemini gem). Test the same question with vs. without it.

• 20 min · Brief the AI with your last 3 calls, workspace, & CRM snapshot before drafting. Notice what it gets right that you’d have re-explained.
• Identify a shared infra to ship context engineering — non-code team knowledge share, iteration, review, & validation (e.g. dept GitHub).

• 30 min · List 3 tasks you’ve done or been asked (personally, or with AI) more than twice. Package the easiest into a reusable skill. Save where teammates can find it. Tell one person to try it.
• 45 min · Pick one skill you run manually each week. Set it on a schedule or event trigger. Route output to Slack/doc/dashboard.

• 60 min · Pick one high-impact skill with low-quality outputs. Add a second agent with a different role (e.g. drafter + checker). Then: watch one cycle without intervening, then progressively upgrade its eval with a pass/fail check against its next 5 outputs.

• 30 min · Set the goal + the test, not the steps. Stop tweaking outputs — tweak the system and rerun. Give an agent the outcome and what “done” looks like, then review the result.

• Watch what's possible for your role — find a few short videos showing AI use cases in your world, then try one yourself.
• Ask a peer: “What AI workflow saves you the most time?” — and find one simple real example of how someone in your role uses AI.
• Identify the “permission moment”: what would need to be true for you to use AI on a real task tomorrow?
• Try 2 AI tools to feel the difference — then commit to ONE for 30 days (hopping at L0 dilutes learning before behaviors form).
• Save one useful output.

• Pick tasks from the easy-wins zone: low-effort, already-on-your-plate work where the bar is “beats what you’d have written alone.” Don’t try to rethink the job yet.
• Commit a persistent-context file the AI loads on its own (CLAUDE.md, a Claude Project, a Copilot agent instruction, a Gemini gem).
• Manually load company context before the prompt.
• Move your work into an AI-native surface as your start point rather than bouncing to the browser — CoWork, Claude/Codex, an IDE, or Copilot inside the M365 app the work already lives in.
• Keep a Personal Prompt Library, with a short list of tuned prompts, refining wording & sharing best ones with team.
• Use basic slash commands e.g. /help.
• Connect AI to at least one real work system so it can reach your work without you pasting it in. An MCP or Claude connector, Copilot wired to SharePoint/Outlook/Teams, or Gemini in Google Workspace. Pick the system your actual work lives in: Slack, Drive, the CRM, Snowflake.
• Use an internal AI tool to summarize meeting notes.
• Compare AI-assisted outputs against your own quality standards, and propose / discuss a simple rubric for better results next time (Evals).
• Time-bound the experiment: 2 weeks of AI-first attempts, then audit which 3 stuck.

• Architect compounding context — structured folders, memory/ directory (patterns, examples, client/knowledge files). A shared SharePoint or Drive folder counts, as long as the AI reads it rather than you.
• Generate the weekly note nobody asked for but everybody reads.
• Exec updates are drafted in <30 min instead of an afternoon.
• Chain two tools together without you in the middle — an MCP-to-MCP hand-off, a Power Automate flow, an Apps Script trigger, a Zap. It pulls from one system and writes to another; you don't touch the middle.
• Ship a shared file, template, skill, Slackbot, or Teams bot your team reaches for without thinking.
• Capture WHY when AI misses — not just the corrected output. The failure log builds better outputs.
• “/enhance context” skill as habit — last 3 calls / recent chats / etc. are extracted & updated in knowledge before you get a response.

• Document one system one-page so it survives you.
• Evals — Define a “review threshold” per skill, and what “agent ran clean” looks like in a sentence before scheduling — then check next 5 runs against it.
• Pick up your first contribution to the internal skill/template marketplace.
• First cross-functional ship is the credibility moment. Pick the highest-goodwill function, not highest-impact.
• Experiment openly and mentor others by sharing patterns and lessons.
• Use hooks to start tracking the team’s Skill usage, to assess usefulness, gaps & prune redundancies.

• Redesign recurring workflows with AI in mind.
• Deep Evals — transitioning HITL → autonomous. Suggest one candidate & map eval checks for your “first autonomous skill” & continue iteration.
• Build agents that run while you’re in other meetings.
• With your core workflow down, look for ways to extend impact beyond your own tasks — document AI workflows that work especially well; clone or expand them to other teams.
• Practice review-vs-trust: pick ONE skill to NOT review for a week; capture deltas.
• Move from agents that run unattended to bespoke apps and dashboards, rebuilt as leadership needs change.
• The motion one builder ships becomes the motion the whole team runs — pick the workflow where that scaling is true, and ship the systemized version.

• Run your day as a manager of agents: review overnight agent outputs, redirect the ones that drifted, decide what ships. (Direct / review / decide is the daily handle.)
• Pick one workflow that crosses two functions. Design a system where AI handles the hand-offs. Ship it. Measure cross-function lift.
• Seed a champion in a function you don’t own; hand them one of your systems to run, so the compounding doesn’t depend on you.
• Prune & merge overlapping systems across teams — one canonical system per workflow, not three.
• “Swarm Architect” (frontier) — autonomous execution loops; agents spawning agents; safety + rollback.

• “What is one task this week where you would not have minded a second opinion?” Go around the room. Low-stakes is the point, not important.
• “What would have to be true for you to try AI on a real task tomorrow?” Take the answers literally — permission, privacy, time, or not wanting to look silly are all real answers.
• “Has anyone here used one of these tools for something at work? Walk us through it.” Ask for the boring example, not the impressive one.
• “What are you worried it gets wrong?” Write the concerns down, then test one live in the meeting.
• Close the session: everyone names the one question they will ask an AI tool before the next meeting. Nothing bigger than that.

• “Whose context do you retype every session?” Have someone read out the paragraph they keep re-explaining. That paragraph is the persistent-context file.
• “Where does our work actually live — SharePoint, Outlook, the CRM, Snowflake?” Then: which one would change the most if AI could read it directly instead of us pasting into it.
• “Show us one output from the last two weeks. What did you fix by hand afterward?” The fix is the context that should have been loaded up front.
• “What prompt have you reused most this month?” If two people describe the same one, you have just found the team's first shared prompt.
• “Who has tried this and given up?” Ask what stopped them. A stalled attempt tells you more about the gate than a success does.

• “Which of the things you built has someone else used without you telling them it existed?” That is the only one that counts toward the gate yet.
• “Where did AI miss this month, and did we write down why?” Have one person read a failure out loud. The log is the asset, not the corrected output.
• “What do people ask you for more than twice a month?” Anything named twice is a skill waiting to be packaged.
• “If a new hire started Monday, what would they still have to ask a human?” That gap is the next shared context file.
• “Who outside this team should be able to use what we built?” Pick the friendliest function to try it on, not the highest-impact one.

• “Name our three shared skills out loud, without looking.” If the room cannot name them, they are not adopted — they are drift.
• “Which of ours could run on a schedule instead of when someone remembers?” Then ask what breaks if nobody watches it for a week.
• “What are we still reviewing out of habit rather than risk?” Pick one to stop reviewing, and agree what you would check instead.
• “Which skill has nobody touched in 60 days?” Prune it or fix it in the meeting. Leaving it undecided is the drift.
• “Where does our work hand off to another function?” Ask what it would take for AI to own that hand-off end to end.

• “Which of our systems would still be running if you were out for a week — and which would we notice first?” Name who would fix it.
• “What did we retire this quarter?” If the answer is nothing, the team is shipping for show rather than need.
• “What does each of our agents get measured on?” If the answer is not a KPI the department already owns, find the real one before adding another.
• “Where is a human still in the loop, and is that judgment or habit?” Separate the two out loud; only one of them is worth keeping.
• “Who in another function could run one of our systems?” Hand it over and pay attention to what they change about it.

• “What has a system changed about its own context or thresholds without us?” Have someone show the actual diff.
• “Where do two of our systems overlap?” Choose the canonical one and retire the other before the meeting ends.
• “Which function has no champion yet?” Ask who will seed one, and what specifically they hand over on day one.
• “What are we still deciding that a system should decide — and what is a system deciding that a human should own?” Both directions are failures worth naming.
• “Output is rising without headcount. What are we doing with the reclaimed hours?” Answer it here, before the org answers it for you.