Written to be read, not skimmed.
Deep dives, head-to-head comparisons, and concept explainers — in plain language, English and Arabic.
The questions everyone asks first
Featured
9 Claude Code workflows that actually save time
Most people use Claude Code like a faster autocomplete. The people who get the most out of it treat it like a teammate. Here are nine concrete ways to do that.
Read the guide →
All guides
137 guidesAuto mode: when to let Claude stop asking permission
Approving every action is safe and unbearable. Approving nothing is fast and reckless. Auto mode is the thing that was missing between them.
Read →Can I put company data into AI?
Nobody wants to be the person who pasted the customer list into a chat window. But "never put anything in" isn't a policy — it's a way of getting the whole team to use AI secretly instead.
Read →Claude Artifacts: turning a session into a shareable page
Some results are worth looking at rather than reading. Artifacts are what happens when Claude stops handing you text and starts handing you a page.
Read →Claude Code Desktop vs the terminal (CLI): which should you use?
Desktop and the command line are two doors into the exact same engine. One asks you to learn a terminal first; the other doesn't. For most professionals that decides it.
Read →Claude Code vs ChatGPT for business work (2026)
They're not competing for the same job. ChatGPT is the best-known place to ask a question and get an answer back. Claude Code is built to open your files, do the work inside them, and hand you a finished result to review. Knowing which job you actually have is most of the decision.
Read →Claude Code vs Cursor vs GitHub Copilot (2026)
These tools aren't three versions of the same thing. They sit at different points on a spectrum from "smart autocomplete" to "autonomous teammate." Knowing which you want is most of the decision.
Read →Claude Cowork vs Claude Code: which one is for you?
They sit one click apart in the same app, share the same engine, and are aimed at completely different people. Here's how to tell which one you actually need.
Read →Claude for Excel, PowerPoint, and Word: making real Office files
For most business teams the question was never "can AI write?" It was "can it hand me the actual spreadsheet?" That answer changed.
Read →Claude in Chrome: letting Claude use your browser
Most of the tedium in knowledge work isn't in your files. It's in a browser tab — the CRM, the portal, the form you fill in forty times. This is the feature that reaches in there.
Read →Claude plans and usage limits: what you're actually paying for
Nobody hits a usage limit because they picked the wrong plan. They hit it because they didn't know the limit was shared, or what was quietly eating it.
Read →Claude vs Microsoft 365 Copilot for business (2026)
One is a feature of the software you already own. The other is a colleague you have to go and find. That difference explains almost every disagreement about which is better.
Read →Context window vs Memory in Claude
Understanding this distinction is the single most clarifying thing for anyone who's ever wondered why Claude 'forgot' something or why it 'knows' something you never told it this session.
Read →Dynamic workflows: when Claude builds its own harness
For most work, one Claude in one context window is plenty. For long, parallel, or adversarial jobs, it helps to have Claude write a small program that runs many Claudes. That's a dynamic workflow.
Read →Getting started with Claude on Desktop (no terminal)
The hard part of "AI for work" was never the AI. It was the command line nobody asked for. Desktop removes it — here's how to go from download to a finished task without ever opening a terminal.
Read →How to ask AI for what you actually want
You're not typing a search query. You're briefing a fast, capable, slightly over-eager contractor who has never met your company and will never ask you a clarifying question unless you invite one.
Read →Is Claude Code safe? Data, privacy, and security explained
The honest answer to "is it safe?" isn't yes or no. It's "which account is it signed in to, and what's it allowed to touch?" — and both of those are things you control.
Read →Loop engineering: stop prompting agents, start designing the loop
For two years the way to use a coding agent was to write a good prompt and steer every step. A handful of people now think that part is ending — that the job is to design the system that does the prompting for you. Here's the honest version of that idea.
Read →Prompt engineering vs Context engineering (2026)
The skill that mattered most in 2023 was writing a clever prompt. The skill that matters most in 2026 is deciding what goes into the context window — and what stays out.
Read →Recursive agents: how a coding agent gets reliable by calling itself
A capable model rarely fails a big job because it isn't smart enough. It fails because the work wasn't specified, split up, or checked. Recursive agents fix the management, not the intelligence.
Read →Session management in Claude Code: working well with a 1M context window
A million-token context window is double-edged. It lets Claude work autonomously for longer, but it also gives clutter more room to accumulate. The skill is knowing, at each turn, whether to continue, rewind, compact, clear, or hand off to a subagent.
Read →The Gulf's AI literacy push: what UAE and Saudi policy means for your team
These programmes aren't aimed at your company. They're aimed at the people you'll be hiring, competing with, and selling to — which is why they end up on your desk anyway.
Read →The software factory: when the assembly line builds the software
Speeding up how fast one person types was never the real prize. The prize is the whole loop — bug report to shipped fix to the next signal — running mostly on its own. That loop is the software factory, and you can start building a miniature one today.
Read →What is an AI agent? (in plain English)
An agent isn't a smarter chatbot. It's a different shape of thing — one that can take actions, look at the results, and decide what to do next, in a loop, until the job is done.
Read →What is Claude Code? (for people who don't write code)
You've used AI that explains how to do your work. Claude Code is the kind that does it — reading your actual files, changing them, and showing you every edit before it sticks. The name throws people off; the idea underneath is for everyone.
Read →What is Claude Cowork? (in plain English)
Chat gives you an answer. Cowork gives you finished work. It's the same Claude, pointed at your actual files, with permission to act on them.
Read →When building gets cheap, taste becomes the job: the new shape of product work
For decades, product process existed to de-risk expensive building before you committed to it. Building just got cheap. This is what happens to taste, teams, planning, and roles when the bottleneck moves from making things to curating them.
Read →Why AI makes things up — and how to catch it
The dangerous failure isn't the answer that's obviously wrong. It's the one that's fluent, formatted, confident, and quietly false — because nothing in the output tells you which one you're holding.
Read →Will AI take my job? A specific answer
"Will AI take my job" is the wrong unit of measurement. Jobs don't get automated; tasks do. Once you split your week into tasks, the question stops being frightening and starts being answerable.
Read →Writing got cheap, understanding didn't: why review is the most leveraged skill in software
Coding agents are extraordinarily good and getting better fast. The interesting consequence is that the hard part of engineering moved from writing code to deciding whether to trust it. How you approach that depends enormously on who you are.
Read →Your first week with Claude Code (no coding background)
You don't need to know how to code to get real work out of Claude Code. You need to get comfortable with one window, a few habits, and the idea that it's okay to just ask.
Read →/clear vs /compact in Claude Code
Both free up context space — but /clear is a fresh start and /compact is a summary that keeps the thread going. Picking the wrong one either loses useful context or keeps stale noise.
Read →Account-in-a-Box — the Sales capstone
Five modules teach you the moves. The capstone proves you can run them as one system — an account where the foundation, the outreach, the deal, the expansion, and the forecast all inherit the same value narrative and the same proof, in English and Arabic. Integration is the test, and it is the part nothing else in the track checks.
Read →Agent vs Subagent in Claude Code
The moment you understand the agent/subagent split, you stop stuffing everything into one long conversation and start keeping your main thread clean.
Read →AI agents vs RPA: what's actually different
One replays exactly what you recorded. The other reads the task and figures out the steps itself. Confusing the two is why "automation projects" so often stall — they're solving different problems.
Read →Answer Engine Optimization (AEO): how to show up in AI answers
Search is splitting in two. One half still shows links; the other half just answers. AEO is how you stay visible in the half that answers — and the moves are surprisingly concrete.
Read →BA Foundation: master the stakeholder map and requirements doc everything inherits
The playbooks show you how to draft a stakeholder map and a requirements doc. This is the module where you master the judgment behind both — who's actually Accountable, what makes a requirement traceable instead of plausible — build them for a real initiative, and check it against a real rubric. The free sample of the Business Analyst deep dives.
Read →Business Analyst with Claude: the operating guide
The playbooks show your team what to do with Claude. This is the guide that keeps every requirement traceable and every decision owned while they do it — the operating model behind the analysis.
Read →Campaign-in-a-Box — the Marketing capstone
Five modules teach you the moves. The capstone proves you can run them as one system — a campaign where the foundation, the calendar, the nurture, the launch, and the measurement all inherit the same promise and the same voice, in English and Arabic. Integration is the test, and it is the part nothing else in the track checks.
Read →Claude Code for UAE and Gulf Business Teams: A Practical Guide
The question isn't whether AI belongs in a Gulf office — it's already there. The real question is whether your team is using it as a toy or as a properly adopted, Arabic-fluent teammate. Here's the difference.
Read →Claude Cowork for business teams: who gets it first, and how to roll it out
Most AI budgets are still pointed at the engineering org. Cowork's usage data says a third of the value is sitting in ops, finance, and HR — where nobody's been given a seat.
Read →Claude Desktop on Linux: the terminal is no longer mandatory
For years, "I'm on Linux" meant "you're using the command line, then." That stopped being true, which changes who on a Linux team can actually use this.
Read →Claude for your team: a practical rollout playbook
Handing your team an AI tool and saying "figure it out" wastes the tool. A little structure — shared conventions, sensible guardrails, and captured know-how — turns it into a multiplier.
Read →Claude vs Gemini for Google Workspace (2026)
Google stopped charging separately for Gemini, which makes "should we also pay for Claude?" a harder question than it was — and a more interesting one.
Read →CLAUDE.md vs Memory in Claude Code
Two systems that remember things across conversations, designed for different owners and different kinds of knowledge.
Read →Close-in-a-Box — the Finance & Ops capstone
Five modules teach you the moves. The capstone proves you can run them as one system — one company's books where the categorization rule, the reconciliation, the forecast, the cash levers, and the board pack all trace to the same source and inherit the same numbers, in English and Arabic. Integration is the test, and it is the part nothing else in the track checks.
Read →Codebase-in-a-Box — the Engineering capstone
The capstone is not a quiz. It's a complete engineering project on one real or sample codebase — five deliverables that run the full arc from orientation to migration, graded against a master rubric that checks both the artefacts and the judgment behind them.
Read →Context engineering: how to get much better answers from Claude
Prompt engineering is about what you ask. Context engineering is about what the model can see when you ask it. The second one matters more, and almost nobody does it on purpose.
Read →Customer Support with Claude: the operating guide
The playbooks show your team what to do with Claude. This is the guide that keeps it safe, on-voice, and on-policy while they do it — and the rule that a person owns every word that reaches a customer.
Read →Data & Analytics with Claude: the operating guide
The playbooks show your analysts what to do with Claude. This is the guide that keeps every number consistent, reconciled, and defensible while they do it — the operating model behind the analysis.
Read →Data Foundation: the dataset, the dictionary & the brief every analysis inherits
The playbooks show you how to profile a file and write a query. This is the module where you master what everything else inherits — what your data actually contains, what your numbers actually mean, and what question you're actually answering — build it for real, and check it against a real rubric. The free sample of the Data & Analysts deep dives.
Read →Do you need a powerful computer to use AI in 2026?
A global memory shortage is pushing the price of high-end laptops sharply upward, and a rumor mill is fuelling buy-now panic. Before you spend, it's worth separating two very different questions — running AI locally versus using AI — because the answer to the one most people care about is refreshingly cheap.
Read →Does Claude Code Support Arabic? RTL, Language, and MENA Teams Explained
The short answer is yes. The more useful answer is what that actually means in practice — for reading, for writing, for right-to-left text, and for a business team working day to day in Arabic.
Read →Engineering Foundation toolkit: CLAUDE.md template, ARCHITECTURE.md template, and the engineering prompt library
The engineering assets your team installs once and keeps: a CLAUDE.md that makes every Claude conversation project-specific, an ARCHITECTURE.md template a new hire can fill in on day one, and a prompt library covering the map, the review, and the clean commit.
Read →Engineering Foundation: the codebase you can change with confidence
The playbook shows you how to map a repo and trace a flow. This is the module where you master the judgment underneath it — what makes a map real versus generic, what a CLAUDE.md actually needs to say, and why 'fix stuff' is the commit message that haunts you six months later — build them for a real codebase, and check them against a real rubric.
Read →Engineering team structure in the AI era: smaller, more senior, and deliberately human
Your org chart is an answer to a question nobody asks anymore. Agents didn't just speed up the work — they dissolved the constraint the whole structure was built around. Here's what actually breaks, the team shapes emerging to replace it, and how to move without losing the culture that made your team worth being on.
Read →Engineering with Claude: the operating guide
The playbooks show your engineers what to do with Claude. This is the guide that keeps it reviewed, proven, and accountable while they do it — the operating model behind the code.
Read →Experiments & charts: the readout and the picture that survive a second look
The playbooks show you how to compute a confidence interval and how to render a PNG. This is the module where those become decisions you can defend — a ship call that survives 'how sure are you?' and a chart whose numbers were checked before anyone saw the picture — assessed against a real rubric instead of one clean-looking result.
Read →Extended Thinking vs Effort in Claude
People ask 'should I use Extended Thinking or /effort?' without realising they're two interfaces to the same underlying capability — giving Claude more room to reason.
Read →Finance & Ops with Claude: the operating guide
The playbooks show your team what to do with Claude. This is the guide that keeps it accurate, defensible, and auditable while they do it — the operating model behind the numbers.
Read →Finance Foundation: the rulebook every report you publish inherits
The playbooks show you how to clean an export and run a close. This is the module where you master the things underneath all of them — how every number is classified, whether the data beneath it can be trusted, and who is allowed to approve what — build them for real, and check them against a real rubric. It's the free sample of the Finance & Ops deep dives, so you can judge the depth before putting a team through the rest.
Read →Founders & PMs Foundation: the product context, market read & codebase map every decision inherits
The playbooks show you how to capture a strategy doc and read a repo. This is the module where you master what everything else inherits — what you're building and for whom, where you really win, and where a feature would actually live — build it for real, and check it against a real rubric. The free sample of the Founders & PMs deep dives.
Read →Founders & PMs with Claude: the operating guide
The playbooks show your team what to do with Claude. This is the operating model underneath — the one that keeps product decisions sound, safe, and defensible while they move fast.
Read →From idea to prototype: spec it, build it clickable, decide before eng touches it
The playbooks show you how to spec one feature and build one prototype. This is the module where those become a repeatable validation engine — a spec that names what you're deliberately not doing, and a prototype you click like a confused first-timer before committing real eng time — assessed against a rubric instead of one lucky good idea.
Read →Hook vs Skill in Claude Code
Hooks and skills both happen automatically — but a hook runs a command at a fixed moment, while a skill shapes how Claude thinks. Mixing them up leads to the wrong tool for the job.
Read →How to use MCP with Claude Code
The Model Context Protocol is the difference between an assistant that can only read your files and one that can check your tickets, query your database, and browse the web. It's easier to set up than it sounds.
Read →Initiative-in-a-Box — the Business Analyst capstone
Five modules teach you the moves. The capstone proves you can run them as one system — a stakeholder map, a requirements doc, a gap and options analysis, a defensible business case, a real sign-off log, and a briefing that survives scrutiny, all tracing to the same initiative. Integration is the test, and it is the part nothing else in the track checks.
Read →Insight-in-a-Box — the Data & Analysts capstone
Five modules teach you the moves. The capstone proves you can run them as one system — a complete analytics function where the profile, the dictionary, the queries, the quality gate, the experiment readouts, and the recurring report all inherit the same source of truth, and every number that leaves the folder can be defended on demand.
Read →Landing a change on a team: branches, pushes and pull requests
Six steps between "I made a change" and "the change is in the real project" — plus the one thing that must never reach a commit, because git's history is permanent by design.
Read →Marketing Campaigns: build lifecycle sequences that move, and stories that earn trust
Content informs; a campaign moves someone. This is the module where you master the two moves that turn finished content into a journey a buyer actually follows — a lifecycle sequence and the proof that earns their trust — build them for your own brand, and check them against a real rubric. It's the layer that sits on top of the free lifecycle and customer-story playbooks.
Read →Marketing Foundation: master the message and voice everything inherits
The playbooks show your team the moves. This is the module where you master the one that everything else inherits — your message and your voice — build it for real, and check it against a real rubric. It's the free sample of the Marketing deep dives, so you can judge the depth before putting a team through the rest.
Read →Marketing Measurement: where last month's results rewrite next month's message
The playbook gives you a monthly review ritual. This module is the judgment that makes it pay off — measuring against the goal not the dashboard, keeping raw customer data out of the chat, and doing the one thing most teams skip: turning a result into a versioned edit to the foundation everything else inherits.
Read →Marketing with Claude: the operating guide
The playbooks show your team what to do with Claude. This is the guide that keeps it safe, on-brand, and on-message while they do it — the operating model behind the work.
Read →MCP vs A2A: the two agent protocols, explained
Two open standards with confusingly similar names. MCP connects one agent to its tools; A2A connects agents to each other. Here's which problem each one solves.
Read →MCP vs Connectors in Claude
Both let Claude reach into your other tools — the difference is whether you're in the terminal or the app, and how much setup you want to do.
Read →Measure & the customer signal: CSAT, VoC, and the loop that feeds everything else
A CSAT score without a driver is anxiety. A driver without a confidence interval is noise. This module is about the judgment in between — reading the number honestly, naming what it means for process versus for reply quality, and distilling a month of tickets into early warning that product and leadership can actually act on.
Read →Onboard & develop: the 30-day plan and the policies people actually read
Most onboarding fails by week two and most policies are never read. This module is the judgment that fixes both — and proves it on real artifacts.
Read →Org change & leadership: run a change without losing the room
Most changes are announced. This module is about running them — the sequence, the honest Q&A, and the feedback loop that closes the gap between what leadership said and what the team heard.
Read →People & HR Foundation: the three documents every hire, review, and org change inherits
The playbooks show you how to clean up a JD and run an interview debrief. This is the module where you master the things underneath all of them — what you're actually hiring for, whether your JD widens or shrinks the pool, and how to say the hard thing in a way the reader can trust — build them for real, and check them against a real rubric.
Read →People & HR with Claude: the operating guide
The playbooks show your team what to do with Claude. This is the guide that keeps it fair, confidential, and defensible while they do it — the operating model behind the people work.
Read →People-in-a-Box — the People & HR capstone
Five modules teach you the systems. The capstone proves you can run them as one — a hiring decision that traces to the same competency framework as the performance review, and an org change that makes sense because the foundation was real.
Read →Plan & forecast: a cash-flow model you can defend and a variance story leadership can act on
The playbooks show your team how to build one cash-flow model and run one variance report. This is the module where you master the forward-looking discipline underneath both — a model where every formula is explained in one plain sentence and that flexes when you change an assumption, and a variance story that explains each gap as price, volume, or timing instead of restating it — built for your own books, in English and Arabic, and assessed against a real rubric.
Read →Plan mode vs Auto mode in Claude Code
One is about when Claude acts. The other is about whether it asks first. They solve different problems and work well together.
Read →Planning & the board: a quarterly plan with a real cut list, and a board narrative you can defend in the room
The playbooks show you how to run one planning cycle and prep one board deck. This is the module where those become the system that runs your company's highest-stakes recurring moments — a plan that names what you're deliberately not doing, and a narrative built before the slides so the room spends its hour on decisions, not survival — assessed against a rubric instead of one good quarter.
Read →Quality & root cause: trust the number before you explain it
The playbooks show you how to audit one file and chase one anomaly. This is the module where those become the two-gate discipline every number clears before it leaves the folder — a quality scorecard with severities, and a root-cause walkthrough that proves whether a number moved because the business changed or because something upstream broke, assessed against a real rubric instead of a confident guess.
Read →Quality & the team: the QA rubric, the coaching system, and the new-hire ramp
The playbooks show you how to score replies and ramp a new hire. This is the module where you master the judgment those recipes can't give you — and prove it on real artifacts.
Read →Reading errors and stack traces
An error isn't a punishment or a verdict on you. It's a machine being literal about where it got stuck — and that literalness is the reason it's fixable at all.
Read →Reviews & retention: calibrated performance, honest engagement, respectful exits
The talent lifecycle doesn't end when someone's hired and onboarded. This module closes the loop — the review that gives real signals, the survey that turns into action, the exit that captures knowledge rather than just revoking access.
Read →Roadmap-in-a-Box — the Founders & PMs capstone
Five modules teach you the moves. The capstone proves you can run them as one system — a complete product organization where the context doc, the validated spec, the decided bet, the roadmap-ready memo, and the board narrative all inherit the same source of truth, and every commitment that reaches a stakeholder can be defended on demand.
Read →Rolling out Claude on Desktop to a non-technical team
The thing that kills most AI rollouts isn't the tool — it's the terminal you asked people to learn first. Start on Desktop and the biggest adoption barrier disappears before day one.
Read →Running the Deal: discovery that surfaces the truth, and proposals that close
Prospecting fills the pipeline; running the deal is where it converts. This is the module where you master the moves that turn a name into a closed deal — discovery that finds the truth, a clean post-call capture, and a proposal that ties price to proof and clears the commercial gate — build them for your own product, and check them against a real rubric. It's the layer that sits on top of the free discovery, post-call, and proposal playbooks.
Read →Safe change: refactor behind a green suite, not faith
The playbook shows you the steps. This module is mastery of the safety discipline — what 'behaviour unchanged' means technically, why characterization tests are the prerequisite not a warm-up, how to keep a refactor from quietly becoming a rewrite, and what it means to prove the cleanup rather than hope it.
Read →Sales Foundation: master the value narrative every deal inherits
The playbooks show your reps the moves. This is the module where you master the ones everything else inherits — what you sell on, who you sell to, and how you handle the pushback — build them for real, and check them against a real rubric. It's the free sample of the Sales deep dives, so you can judge the depth before putting a team through the rest.
Read →Sales Measurement: where the quarter's won and lost rewrites the value narrative
The playbook gives you a pipeline review ritual. This module is the judgment that makes it pay off — measuring against the number not the activity dashboard, keeping raw lead data out of the chat, and doing the one thing most teams skip: turning a quarter's won and lost into a versioned edit to the foundation every deal inherits.
Read →Sales with Claude: the operating guide
The playbooks show your reps what to do with Claude. This is the guide that keeps it safe, compliant, and honest while they do it — the operating model behind the work.
Read →Scheduled agent vs /loop in Claude Code
Both repeat work automatically — but a scheduled agent is fire-and-forget on a calendar, while /loop is an in-session timer. Pick the wrong one and you're either over-engineering or under-automating.
Read →Shipping features: spec → plan → build → prove → commit, in that order
The playbook shows you the loop. This module is mastery of why the order matters — a spec you can test against, a plan wrong enough to critique while it's still prose, an implementation the acceptance criteria can prove, and a diff you read as the author of record before it lands.
Read →Sign-off: circulation, conflict, and the doc everyone actually agreed to
The playbook shows you the tracker. This module is mastery of the orchestration layer — the discipline of chasing without nagging, escalating a genuine disagreement to a decision-maker instead of averaging it away, and the difference between a doc that looks finished and a doc that is actually signed.
Read →Signal to decision: turn scattered feedback into a defensible bet, and options into a call you can defend
The playbooks show you how to synthesize one feedback pile and compare options once. This is the module where those become a repeatable judgment engine — a signal traceable to real quotes from real distinct customers, and a memo that survives its own strongest counter-argument before you circulate it — assessed against a rubric instead of one persuasive paragraph.
Read →Skill vs Plugin in Claude Code
Skills are ingredients; plugins are recipes. Knowing the difference saves you from building what someone already packaged.
Read →Skill vs Slash command in Claude Code
People create a skill when they should have made a command, and vice versa. The distinction is simple once you see it — one fires automatically, the other fires when you say so.
Read →Slop and determinism: the shape that makes AI work reliable
AI didn't change what good software looks like — it just made it easier to skip. The durable fix is to put determinism at the core of your system and push the AI's guesswork out to the edges.
Read →Subagent vs Agent team (Workflow) in Claude Code
Both involve Claude delegating work to other Claudes — the difference is one helper vs many, and a side-quest vs a divide-and-conquer strategy.
Read →Support Foundation: the voice and policy every reply inherits
The playbooks show your agents the moves. This is the module where you master the ones everything else inherits — how you sound, what you can promise, and the templates every reply starts from — build them for real, and check them against a real rubric. The free sample of the Customer Support deep dives.
Read →Support-in-a-Box — the Customer Support capstone
Five modules teach you the playbooks. The capstone proves you can run them as one system — a complete support operation where voice, policy, macros, the queue, the QA standard, the measure loop, and the operating rhythm all inherit the same source of truth.
Read →The analysis: turn a signed-off requirement into a gap, a risk register, and a defensible recommendation
The playbooks show you how to compare current to future state, sort concerns into a SWOT, and score options on a table. This is the module where those become the analysis a delivery team can actually act on — every gap traced to its real cause, every risk owned and revisited, every option scored on identical terms with a recommendation that names what would change it — assessed against a rubric instead of a plausible-sounding first draft.
Read →The BA Foundation toolkit: the files your team installs
A document you wrote once helps you once. A document your team installs helps every initiative forever. This is the toolkit that turns the Foundation module's two files into shared infrastructure — copy it, fill it with your initiative, and every downstream document inherits it.
Read →The big move: migration at scale, with the hard cases named
The playbook shows you the sweep. This module is mastery of the judgment layer — blast-radius thinking before a single edit, the mechanical-90% versus decision-10% split, why the flagged list is the most important output, and what a documented decision looks like versus a confident guess that compiled.
Read →The big play: orchestrate a renewal or strategic account, end to end
The playbooks get you a renewal. This is the module where you learn to run one — a single high-stakes account moment where the foundation, the engine, and the deal mechanics all come together, in two languages, with every sign-off secured before the offer ships instead of chased on the day. You build the runbook and the value story for real, and you are graded on whether they would actually hold.
Read →The cash levers: collect what you're owed and cut spend with evidence, not vibes
The playbooks get you one collections run and one spend audit. This is the module where the two levers that move cash become a discipline — collect what you've already earned before chasing a new sale, and cut the spend you're bleeding on tools nobody opens — with every chase traced to a real invoice, every cut backed by evidence, in two languages, and graded on whether a CFO would sign the numbers.
Read →The close & the board: run month-end end to end and assemble a pack you can defend
The playbooks give you a close and a board pack. This is the module where they become one thing — the recurring climax where the foundation, the report, the plan, and the cash levers come together into an ordered close a teammate could re-run, and a board pack where every number traces to a verified source and a person, not the preparer, signs it. Authored in Arabic, graded against a rubric, not a vibe.
Read →The code quality engine: review that catches the real bug and commits that explain why
The playbooks show you how to review a diff and untangle a working tree. This module is mastery of the judgment layer — the adversarial framing that flushes out the real bug, the verification step that kills false positives before they embarrass you, and the one-concern-per-commit discipline that means the next engineer can actually act on git blame.
Read →The content engine: turn your foundation into a pipeline that ships every week
The playbooks show your team how to draft, schedule, and repurpose. This is the module where those separate moves become one machine — a brief-driven pipeline that turns your foundation into a predictable stream of on-brand content, in English and Arabic, and gets assessed against a real rubric instead of a single lucky draft.
Read →The Data Foundation toolkit: the files your team queries from
A metric dictionary you wrote once helps you once. One your team queries from helps every report, forever. This is the toolkit that turns the Foundation module's three files into shared infrastructure — copy it, fill it with your real data, and every analysis starts from the same truth.
Read →The decision package: the business case, the traceable backlog, and the workshop that actually decides
The playbooks show you how to cost a case, draft a story, and recap a workshop. This is the module where you master the judgment those recipes can't give you — and prove it on real artifacts.
Read →The exec briefing: compress an initiative into two minutes leadership trusts
The playbook shows you the steps to compress one initiative into one page. This module is where compression becomes a discipline you can defend under scrutiny — leading with the ask, sourcing every number, and never letting brevity slide into spin. Graded against a rubric, not a vibe.
Read →The Finance Foundation toolkit: the files your team closes from
A rule you wrote once helps one close. A rule your team installs helps every close forever. This is the toolkit that turns the Foundation module's three files into shared infrastructure — copy it, fill it with your own books, and every later reconciliation, budget, and board pack inherits it.
Read →The Founders Foundation toolkit: the files every spec, prototype & memo pastes from
A context doc you wrote once helps you once. One your whole team pastes into every chat helps every spec, prototype, and decision, forever. This is the toolkit that turns the Foundation module's three files into shared infrastructure — copy it, fill it with your real company, and every product conversation starts from the same truth.
Read →The hiring engine: from open role to offer without guesswork
The playbooks show you how to run an interview and build a hiring kit. This is the module where you master why most panel hiring fails — and build a structured, bias-flagged, traceable system that produces a hire you can defend.
Read →The launch: orchestrate one moment where everything fires at once
The playbooks get you a launch. This is the module where you learn to run one — a single moment where the foundation, the engine, and the campaigns all fire at once, in two languages, with every sign-off secured before the day instead of chased at 11pm. You build the runbook and the comms kit for real, and you are graded on whether they would actually hold.
Read →The Marketing Foundation toolkit: the files your team installs
A document you wrote once helps you once. A document your team installs helps every task forever. This is the toolkit that turns the Foundation module's two files into shared infrastructure — copy it, fill it with your brand, and every later job inherits it.
Read →The monthly report: turn your foundation into a close-and-report cycle you trust
The playbooks show you how to run a reconciliation, a spend audit, and a leadership summary once. This is the module where those three moves become one machine — a monthly close-and-report cycle that turns a messy export into numbers leadership trusts, in English and Arabic, and gets assessed against a real rubric instead of whoever survived the month-end fire drill.
Read →The operating system: weekly rhythm and incident comms
The playbooks teach the moves. This module is the discipline that runs them — a weekly operating rhythm that compounds, and an incident kit that turns a crisis into a managed response instead of a fire you stare at.
Read →The outreach engine: turn your foundation into pipeline that fills itself
The playbooks show your reps how to write a grounded opener and prep a call. This is the module where those separate moves become one machine — a prospecting system that turns cold names into researched, on-narrative pipeline, in English and Arabic, and gets assessed against a real rubric instead of a single lucky cold email.
Read →The People & HR Foundation toolkit: the files your team hires and grows from
A job description you wrote once fills one role. A competency framework your team installs shapes every hire, every review, and every promotion conversation forever. This is the toolkit that turns the Foundation module's three files into shared infrastructure — copy it, fill it with your own roles, and every later JD, review, and difficult conversation inherits it.
Read →The query & join engine: turn a stakeholder ask into an auditable query, and two files into one trustworthy dataset
The playbooks show you how to write one query you can defend and join two files once without losing a row. This is the module where those become a repeatable engine — a query that ties back to a number people already trust, and a join that proves it didn't lose a row or a dirham — in English and Arabic, assessed against a rubric instead of one lucky correct answer.
Read →The queue engine: turn your support inbox into a system that answers less
The playbooks show your agents how to triage a queue and draft a sharp reply. This is the module where those separate moves become one machine — a queue engine that turns a pile of incoming tickets into root-cause clusters, engineering-ready bug reports, and self-serve articles that stop the next wave, in English and Arabic, assessed against a real rubric instead of one well-handled complaint.
Read →The reporting system: the monthly report that compounds, and self-serve analytics
The playbooks show you how to build one good report and stand up one good system. This is the module where both stop being projects and become operations — assembling Modules 1 through 4 into a recurring report a stakeholder trusts on sight, and a self-serve system that holds its guardrails even when you're not in the room. Graded against a rubric, not a vibe.
Read →The roadmap pipeline: the weekly update system, and the full request-to-roadmap chain
The playbooks show you how to draft one update and chain five playbooks once. This is the module where those become the pipeline that keeps a product org informed and a roadmap honest — a sent update your investors and team can trust every week, and a PRD where every claim is backed by something real — assessed against a rubric instead of one good week.
Read →The Sales Foundation toolkit: the files your team installs
A document you wrote once helps you once. A document your team installs helps every deal forever. This is the toolkit that turns the Foundation module's three files into shared infrastructure — copy it, fill it with your product, and every later call, email, and proposal inherits it.
Read →The Support Foundation toolkit: the files your team installs
A voice guide you wrote once helps you once. One your team installs helps every reply, forever. This is the toolkit that turns the Foundation module's three files into shared infrastructure — copy it, fill it with your team's voice, and every draft starts from the same truth.
Read →Vibe coding, explained — what it is and how to do it well
Vibe coding is building software by describing what you want and letting AI write it — steering by feel rather than by syntax. It's genuinely powerful and genuinely easy to do badly.
Read →What are Claude Skills? (in plain English)
The tell that you need a skill is repetition — the third time you explain the same conventions to a fresh session, you've stopped briefing and started re-typing something that should live in a file.
Read →What is Claude Tag? The AI teammate that lives in your Slack
You already have a channel where the work gets coordinated. Claude Tag puts a capable teammate in it — one you @mention like anyone else, that learns the channel over time and keeps working while you're in a meeting.
Read →Where does this come from, where is it used?
Every trace runs one of two ways — backward toward where something came from, or forward toward what depends on it. The second one is the question people skip, and it's the one that decides whether a change is safe.
Read →Where your AI spend actually goes — and how to cut it
When an AI bill jumps, the instinct is to blame the model or shorten the answers. Both miss the real driver: what you feed in. Here's why input dominates the cost, and what actually moves the number.
Read →Which Claude model should you use? Haiku vs Sonnet vs Opus vs Fable
The difference between people who get consistently great results and people who get stuck or overspend often comes down to one habit — matching the model to the difficulty of the job.
Read →Your team's first AI ground rules
A policy nobody reads isn't a policy — it's a document. The version that actually changes behaviour is short enough to remember, permissive enough to be worth following, and clear about one thing: who's accountable.
Read →