30 Claude Prompts That Build Org Charts

You are an org-design consultant who specializes in matrix structures. <context> I need a matrix org chart where people report both into a function and into projects, delivered as a self-contained Mermaid diagram that renders instantly and makes the two reporting axes obvious. </context> <inputs> - Functional managers: [E.G. ENG MANAGER, DESIGN MANAGER, QA MANAGER] - Project / product leads: [E.G. PROJECT A LEAD, PROJECT B LEAD] - People and their function: [NAME: FUNCTION] - Which project(s) each person works on: [NAME -> PROJECT] - Which line is the primary (solid) reporting line: [FUNCTIONAL OR PROJECT] </inputs> <task> Build a matrix chart with functional managers across one axis and project leads across the other, each person connected by a solid line to their primary manager and a dotted line to their secondary. Group functions and projects clearly so the two-axis nature is unmistakable. </task> <constraints> - Valid Mermaid flowchart TD (or LR if it reads better for a matrix); renders with no edits. - Solid line = primary manager, dotted line = secondary; use subgraphs for functions and for projects. - No node connected to two solid lines; that defeats the matrix clarity. </constraints> <format> Return the Mermaid code in a code block, then a short note on who each person's primary manager is and the classic two-boss risks to watch. </format>

You are an org designer who clarifies dual-reporting relationships. <context> Several of my people have two managers and I need a chart that makes each person's solid-line and dotted-line boss crystal clear, delivered as a self-contained Mermaid diagram that renders instantly. </context> <inputs> - People with dual reporting: [NAME: ROLE] - Each person's solid-line (primary) manager: [NAME -> MANAGER] - Each person's dotted-line (secondary) manager: [NAME -> MANAGER] - What the solid line owns vs the dotted line: [DESCRIBE E.G. CAREER VS DAY-TO-DAY] - Other single-report team members for context: [LIST] </inputs> <task> Build a chart placing each dual-reporting person with a solid arrow to their primary manager and a dotted arrow to their secondary manager, and a small legend node explaining what each line means (who owns reviews, priorities, career growth). Include single-report peers for context. </task> <constraints> - Valid Mermaid flowchart TD; renders unchanged. - Exactly one solid line per person; dotted lines clearly styled; include a legend subgraph. - Labels to name + role; no invented people. </constraints> <format> Return the Mermaid code in a code block, then a two-line note on the most common friction point in each dual-reporting pair. </format>

You are an org strategist for companies structured by both product line and geography. <context> I need a matrix org chart crossing product lines with regions, delivered as a self-contained Mermaid diagram that renders instantly, showing how leaders on each axis intersect. </context> <inputs> - Product lines and their global heads: [PRODUCT: HEAD] - Regions and their heads: [REGION: HEAD] - Local product leaders (the intersections): [PRODUCT x REGION -> LEADER] - Primary reporting line: [PRODUCT-LED OR REGION-LED] - Shared central functions: [LIST] </inputs> <task> Build a matrix chart with global product heads on one axis and regional heads on the other, and the intersection roles (e.g. "Product A lead, EMEA") connected by a solid line to the primary axis and a dotted line to the secondary. Show shared central functions once. </task> <constraints> - Valid Mermaid flowchart TD or LR; renders with no edits. - Solid = primary axis, dotted = secondary; group products and regions in subgraphs. - Every intersection role connects to exactly one product head and one region head; no orphans. </constraints> <format> Return the Mermaid code in a code block, then a short note on which axis holds budget authority in this design and why that matters. </format>

You are an operating-model designer who balances centralized expertise with business-unit autonomy. <context> I need a matrix chart showing centers of excellence (CoEs) crossing business units, delivered as a self-contained Mermaid diagram that renders instantly. </context> <inputs> - Centers of excellence and their leads: [E.G. DATA COE, DESIGN COE] - Business units and their heads: [BU: HEAD] - Practitioners embedded in BUs from each CoE: [PERSON: COE, EMBEDDED IN BU] - Solid-line owner: [COE OR BU] - Shared standards the CoE sets: [DESCRIBE] </inputs> <task> Build a chart with CoEs on one axis and business units on the other, embedded practitioners connected by a solid line to their primary owner and a dotted line to the secondary, and a note node summarizing what standards each CoE governs across all BUs. </task> <constraints> - Valid Mermaid flowchart TD or LR; renders unchanged. - Solid = primary, dotted = secondary; subgraphs for CoEs and for BUs. - No practitioner with two solid lines; keep the CoE governance note concise. </constraints> <format> Return the Mermaid code in a code block, then a two-line note on how to keep the CoE from becoming a bottleneck for the BUs. </format>

You are an org-design expert who diagrams balanced matrix structures where power is shared evenly. <context> I need a balanced matrix org chart where functional and project authority are roughly equal, delivered as a self-contained Mermaid diagram that renders instantly and shows the shared authority explicitly. </context> <inputs> - Functional managers: [NAMES, FUNCTIONS] - Project managers: [NAMES, PROJECTS] - Shared team members: [NAME: FUNCTION, ON WHICH PROJECT] - What functional managers decide: [E.G. HOW, WHO, CAREER] - What project managers decide: [E.G. WHAT, WHEN, PRIORITY] </inputs> <task> Build a balanced matrix chart where each shared member connects with equal-weight lines to both a functional and a project manager, plus two legend nodes stating exactly which decisions each type of manager owns, so the shared authority is explicit rather than implied. </task> <constraints> - Valid Mermaid flowchart TD or LR; renders with no edits. - Use the same line style for both manager links to signal balance; include the two decision-rights legend nodes. - Group functions and projects in subgraphs; no invented people. </constraints> <format> Return the Mermaid code in a code block, then a short note on the coordination overhead a balanced matrix creates and one way to reduce it. </format>

You are a startup org advisor who designs lean structures for tiny founding teams. <context> I have an early-stage startup and need an org chart that reflects who owns what today, delivered as a self-contained Mermaid diagram that renders instantly, plus a text fallback. </context> <inputs> - Founders and their focus areas: [NAME: FOCUS] - First hires and roles: [NAME: ROLE] - Functions currently owned by a founder wearing two hats: [FOUNDER -> FUNCTIONS] - Contractors / part-timers: [LIST] - Functions with no owner yet: [LIST] </inputs> <task> Build a lean org chart showing founders and their primary functions, first hires beneath, founders who own multiple functions shown with a node per hat, contractors as a dotted-line group, and unowned functions marked "(no owner yet)" so the gaps are visible. </task> <constraints> - Valid Mermaid flowchart TD; renders with no edits. - Keep it lean, no fake layers; dotted lines for contractors; dashed nodes for unowned functions. - Labels to name + function; no invented hires. </constraints> <format> Return the Mermaid code in a code block, then an indented text hierarchy fallback and a one-line note on which unowned function to hire for first. </format>

You are a scaling advisor who helps post-funding startups design their next org structure. <context> We just raised a round and need a scaled org chart introducing real management layers, delivered as a self-contained Mermaid diagram that renders instantly. </context> <inputs> - CEO and current leadership: [NAMES, TITLES] - New leadership roles to add: [E.G. VP ENG, HEAD OF SALES] - Existing teams and their sizes: [TEAM: SIZE] - Planned new teams: [LIST] - Which current people step into leadership: [PERSON -> NEW ROLE] </inputs> <task> Build a scaled org chart adding a leadership layer beneath the CEO, mapping existing team members into the new structure, marking newly created leadership roles as "(new)" and any external hire as "(to hire)", and grouping each function so the post-round shape is clear. </task> <constraints> - Valid Mermaid flowchart TD; renders unchanged. - Subgraph per function; dashed nodes for roles to hire; tag promoted-from-within roles. - Do not over-layer; one management tier is usually enough at this stage. </constraints> <format> Return the Mermaid code in a code block, then a short note listing the new roles in priority hiring order. </format>

You are an org-planning consultant who visualizes the gap between today's team and the target org. <context> I need two org charts side by side in concept: the org today and the org in [TIMEFRAME], delivered as self-contained Mermaid diagrams that render instantly, so the hiring plan is obvious. </context> <inputs> - Current team: [NAMES, ROLES, MANAGERS] - Target timeframe: [E.G. 12 MONTHS] - Roles to add by then: [ROLE: WHEN] - Roles that change or get promoted: [PERSON -> NEW ROLE] - Total target headcount: [NUMBER] </inputs> <task> Produce two Mermaid charts: (1) the current org, and (2) the future-state org with all planned roles added and marked "(hire)" or "(promo)", grouped by function. Make the delta between the two visually obvious through consistent layout. </task> <constraints> - Two valid Mermaid flowchart TD diagrams in separate code blocks; both render with no edits. - Use dashed nodes for future hires; keep the same node order in both so the diff is readable. - No invented roles beyond my list. </constraints> <format> Return both Mermaid diagrams in labeled code blocks, then a hiring table (Role, Function, Target month, Promo or external) summarizing the plan. </format>

You are a co-founder alignment coach who clarifies who owns what between founders. <context> My co-founders and I have blurry responsibilities and I need a chart that cleanly splits ownership, delivered as a self-contained Mermaid diagram that renders instantly. </context> <inputs> - Founders: [NAMES] - Every major function in the company: [LIST E.G. PRODUCT, ENG, SALES, FINANCE, HIRING] - Who is best suited to each: [FUNCTION -> FOUNDER, IF KNOWN] - Functions currently claimed by more than one founder: [LIST] - Decision areas needing a single owner: [LIST] </inputs> <task> Build a chart mapping each founder to the functions they own, assigning any contested function to a single primary owner (with the other as dotted-line backup), and flagging any function no founder is suited for as "(needs a hire)". The goal is one clear DRI per function. </task> <constraints> - Valid Mermaid flowchart TD; renders with no edits. - Each function has exactly one solid owner; dotted line for backup only. - Mark hire-needed functions with a dashed node; no invented functions. </constraints> <format> Return the Mermaid code in a code block, then a short ownership table (Function, Primary owner, Backup) and one note on the riskiest overlap you resolved. </format>

You are a workforce-planning analyst who visualizes phased headcount growth. <context> I need a chart showing how the org grows quarter by quarter, delivered as a self-contained Mermaid diagram that renders instantly, plus a headcount table. </context> <inputs> - Current headcount by function: [FUNCTION: COUNT] - Hiring plan per quarter: [QUARTER -> ROLES / FUNCTIONS] - Budget or headcount cap: [NUMBER OR BUDGET] - Priority functions to grow first: [LIST] - Any planned reorg or team split: [DESCRIBE] </inputs> <task> Build a Mermaid diagram (timeline or grouped flowchart) showing each quarter as a stage with the roles added that quarter, grouped by function, so the growth path is visible. Reflect any team split as a branch at the quarter it happens. </task> <constraints> - Valid Mermaid syntax (timeline or flowchart LR); renders with no edits. - Group additions by quarter; keep function labels consistent across quarters. - Respect the headcount cap; do not add roles beyond it. </constraints> <format> Return the Mermaid code in a code block, then a headcount table (Function, current, +Q1, +Q2, +Q3, +Q4, end total) that ties to the cap. </format>

You are a project-governance expert who builds clear RACI responsibility matrices. <context> I need a RACI matrix for a project, delivered as a ready-to-paste Markdown table where each task has exactly one Accountable owner and no ambiguity. </context> <inputs> - Project name and goal: [NAME, OUTCOME] - Key tasks / deliverables: [LIST 6-12] - Roles / people involved: [LIST] - Known owners for any task: [TASK -> OWNER] - Approval or sign-off steps: [LIST] </inputs> <task> Build a RACI matrix with tasks as rows and roles as columns, filling each cell with R, A, C, or I. Enforce exactly one A per row, at least one R per row, and keep C and I minimal. Add a short definitions line and flag any row where you had to guess the owner. </task> <constraints> - Return a valid Markdown table that renders cleanly; one A per row, no blank rows. - Do not over-assign C; only include consult roles that genuinely add value. - Use the roles I gave you; mark guessed assignments with an asterisk. </constraints> <format> Return the RACI table, then a one-line RACI key and a short list of any rows that need my confirmation. </format>

You are a decision-governance consultant who clarifies who decides what using DACI or RAPID. <context> I need a decision-rights chart for a set of recurring decisions, delivered as a ready-to-paste Markdown table so it is clear who drives, decides, and is consulted. </context> <inputs> - Framework: [DACI OR RAPID] - Recurring decisions to map: [LIST 5-10] - Roles / people: [LIST] - Known decider for any decision: [DECISION -> DECIDER] - Where past decisions stalled: [DESCRIBE] </inputs> <task> Build a decision-rights table with decisions as rows and the chosen framework's roles (e.g. Driver, Approver, Contributors, Informed for DACI) as columns, assigning each decision exactly one Approver/Decider, and add a note on any decision that historically stalled and how the clear owner fixes it. </task> <constraints> - Valid Markdown table; exactly one final decider per decision row. - Use only the framework I chose; keep contributor lists lean. - Flag guessed assignments with an asterisk; no blank rows. </constraints> <format> Return the decision-rights table, then a one-line key for the framework roles and a short note on the decisions most likely to speed up now. </format>

You are an org-clarity consultant who documents role responsibilities to remove overlap. <context> I need a role-and-responsibility matrix for a team, delivered as a ready-to-paste Markdown table mapping each responsibility to a single owner and any supporters. </context> <inputs> - Team / function: [NAME] - Roles on the team: [LIST] - Core responsibilities / areas: [LIST 8-15] - Areas currently owned by more than one person: [LIST] - Areas nobody clearly owns: [LIST] </inputs> <task> Build a matrix with responsibilities as rows and roles as columns, marking one Owner (O) and any Supporters (S) per responsibility. Resolve every double-owned area to a single Owner, mark unowned areas as "OWNER: TBD", and keep supporters minimal. </task> <constraints> - Valid Markdown table; exactly one Owner per row (or explicit TBD). - Do not leave silent overlaps; every contested area gets one clear owner. - Use only the roles I listed; no invented responsibilities. </constraints> <format> Return the responsibility matrix, then a short list of the overlaps you resolved and the areas still marked TBD for me to assign. </format>

You are a process designer who maps who does what across the steps of a workflow. <context> I need a swimlane view of a process showing which role owns each step, delivered as a self-contained Mermaid diagram that renders instantly. </context> <inputs> - Process name: [NAME] - Roles involved (the lanes): [LIST] - Ordered steps: [LIST IN SEQUENCE] - Which role performs each step: [STEP -> ROLE] - Any handoffs or approvals between roles: [LIST] </inputs> <task> Build a Mermaid flowchart organized so each role's steps are grouped in its own subgraph (acting as a swimlane), with arrows showing the process flowing step to step and crossing lanes at each handoff, so responsibility for every step is unambiguous. </task> <constraints> - Valid Mermaid flowchart LR with one subgraph per role as a swimlane; renders with no edits. - Every step sits in exactly one lane; handoffs shown as arrows crossing between subgraphs. - Label approval steps distinctly; no orphan steps. </constraints> <format> Return the Mermaid code in a code block, then a short note on the handoffs most likely to cause delays and who to make accountable for each. </format>

You are an incident-management designer who builds clear escalation and on-call responsibility charts. <context> I need an escalation path showing who is responsible at each tier and when to escalate, delivered as a self-contained Mermaid diagram that renders instantly. </context> <inputs> - Incident types or severities: [E.G. SEV1, SEV2, SEV3] - Tiers / on-call roles: [E.G. FRONT LINE, ON-CALL ENG, ENG MANAGER, EXEC] - Who holds each tier: [TIER -> NAME OR ROTATION] - Escalation triggers: [E.G. UNRESOLVED IN X MINUTES] - Notification targets per severity: [LIST] </inputs> <task> Build an escalation chart showing the flow from detection through each responsibility tier, with decision nodes for the escalation triggers (e.g. "resolved? no -> escalate") and severity-based branches that notify the right people, so on-call responsibility is unambiguous at every step. </task> <constraints> - Valid Mermaid flowchart TD with decision diamonds for triggers; renders with no edits. - Each tier is a distinct node; escalation arrows labeled with the trigger condition. - Cover the severities I listed; no dead-end nodes. </constraints> <format> Return the Mermaid code in a code block, then a short escalation table (Severity, First responder, Escalates to, Trigger) as a text companion. </format>