> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getthread.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Build with Super Magic

> Extend Super Magic with Linear, Notion, and Zapier connectors, package reusable Skill Library skills, and ship Automagically runbooks that run unattended.

export const MarkComplete = ({id, signalDone = false}) => {
  const KEY = "thread-onboarding-completed";
  const read = () => {
    try {
      return JSON.parse(localStorage.getItem(KEY) || "[]");
    } catch (e) {
      return [];
    }
  };
  const [localDone, setLocalDone] = useState(false);
  const done = signalDone || localDone;
  useEffect(() => {
    const sync = () => setLocalDone(read().includes(id));
    sync();
    window.addEventListener("thread-onboarding-updated", sync);
    return () => window.removeEventListener("thread-onboarding-updated", sync);
  }, [id]);
  const toggle = () => {
    if (signalDone) return;
    const list = read();
    const next = list.includes(id) ? list.filter(x => x !== id) : [...list, id];
    try {
      localStorage.setItem(KEY, JSON.stringify(next));
    } catch (e) {}
    setLocalDone(next.includes(id));
    window.dispatchEvent(new Event("thread-onboarding-updated"));
  };
  return <button onClick={toggle} style={{
    width: "100%",
    padding: "0.7rem 1rem",
    marginTop: "1.5rem",
    borderRadius: "8px",
    border: "1px solid " + (done ? "#00B398" : "rgba(128,128,128,0.35)"),
    background: done ? "rgba(0,179,152,0.12)" : "transparent",
    color: done ? "#00B398" : "inherit",
    fontWeight: 600,
    fontSize: "0.95rem",
    cursor: "pointer",
    display: "flex",
    alignItems: "center",
    justifyContent: "center",
    gap: "0.5rem"
  }}>
      <span aria-hidden="true">{done ? "✓" : "○"}</span>
      {done ? "Completed" : "Mark as complete"}
    </button>;
};

export const ByRoleProgress = () => {
  useEffect(() => {
    const KEY = "thread-onboarding-completed";
    const TEAL = "#00B398";
    const BASE = "/start-here/roles/";
    const DONE_ICON = '<svg class="thread-rc-doneicon size-4" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="#00B398" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">' + '<path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/>' + '<polyline points="22 4 12 14.01 9 11.01"/></svg>';
    const COURSES = [{
      slug: "technician",
      steps: ["why-thread", "get-around-inbox", "day-one-setup", "daily-workflows", "ai-toolkit", "notifications-and-customers"]
    }, {
      slug: "dispatcher",
      steps: ["why-dispatch-in-thread", "read-the-board", "assign-and-schedule", "ai-for-dispatch"]
    }, {
      slug: "service-ops-manager",
      steps: ["set-up-the-desk", "sla-and-dispatch", "analytics-and-qa", "roll-out-and-adopt"]
    }, {
      slug: "csm-account-manager",
      steps: ["client-intelligence-and-health", "qbrs-and-reporting", "retention-and-expansion"]
    }, {
      slug: "security-compliance-owner",
      steps: ["security-work-in-thread", "data-and-compliance", "security-runbooks"]
    }, {
      slug: "sales-business-development",
      steps: ["the-ai-service-pitch", "quote-and-handoff"]
    }, {
      slug: "msp-owner-leadership",
      steps: ["the-rollout", "outcomes-and-analytics", "scale-ai-service"]
    }, {
      slug: "automation-engineer",
      steps: ["flows-and-intents", "thread-mcp-and-api", "build-with-super-magic"]
    }];
    const COURSE_SLUGS = new Set(COURSES.map(c => c.slug));
    const readLocal = () => {
      try {
        return JSON.parse(localStorage.getItem(KEY) || "[]");
      } catch (e) {
        return [];
      }
    };
    const isDone = (done, id) => done.includes(id);
    const decorate = () => {
      const done = readLocal();
      const scope = document.getElementById("sidebar-content") || document;
      const links = [...scope.querySelectorAll('a[href*="' + BASE + '"]')].filter(a => !a.closest("main"));
      links.forEach(a => {
        const m = (a.getAttribute("href") || "").match(/\/start-here\/roles\/([^/?#]+)\/([^/?#]+)/);
        if (!m) return;
        if (!COURSE_SLUGS.has(m[1])) return;
        const id = m[1] + "/" + m[2];
        const d = isDone(done, id);
        const has = a.querySelector(".thread-rc-check");
        if (d && !has) {
          const s = document.createElement("span");
          s.className = "thread-rc-check";
          s.textContent = "✓ ";
          s.style.color = TEAL;
          s.style.fontWeight = "700";
          a.insertBefore(s, a.firstChild);
        } else if (!d && has) {
          has.remove();
        }
      });
      COURSES.forEach(course => {
        const li = scope.querySelector('li[id="' + BASE + course.slug + '"]');
        if (!li) return;
        const row = li.querySelector(":scope > button") || li.querySelector(":scope > a") || li.firstElementChild;
        if (!row) return;
        const nameSpan = [...row.querySelectorAll("span")].find(s => s.textContent.trim() && !s.classList.contains("thread-rc-coursecheck"));
        if (!nameSpan) return;
        const allDone = course.steps.length > 0 && course.steps.every(s => isDone(done, course.slug + "/" + s));
        const has = nameSpan.querySelector(".thread-rc-coursecheck");
        if (allDone && !has) {
          const s = document.createElement("span");
          s.className = "thread-rc-coursecheck";
          s.setAttribute("aria-hidden", "true");
          s.style.display = "inline-flex";
          s.style.alignItems = "center";
          s.style.verticalAlign = "-0.2em";
          s.style.marginRight = "0.35em";
          s.innerHTML = DONE_ICON;
          nameSpan.insertBefore(s, nameSpan.firstChild);
        } else if (!allDone && has) {
          has.remove();
        }
      });
    };
    decorate();
    const iv = setInterval(decorate, 600);
    window.addEventListener("thread-onboarding-updated", decorate);
    window.addEventListener("storage", decorate);
    return () => {
      clearInterval(iv);
      window.removeEventListener("thread-onboarding-updated", decorate);
      window.removeEventListener("storage", decorate);
    };
  }, []);
  return null;
};

<ByRoleProgress />

Super Magic is the surface where your automation becomes reusable. You can widen what it reaches with connectors, capture a proven workflow as a skill your whole team runs, and hand the repetitive runbooks to Automagically to execute unattended. This is where a good automation engineer stops resolving tickets and starts shipping capability.

## Connectors: give Super Magic more reach

Out of the box Super Magic works with Thread's own data and its built-in integrations. **Connectors** extend it to external tools over MCP — so Super Magic (and Thread MCP) can read and act in systems your desk already lives in. [Add external tools to Super Magic with connectors (Super MCP)](/super-magic/add-external-tools-to-super-magic-with-connectors-super-mcp) is the setup path; the high-value ones for automation work:

| Connector  | What it unlocks                                                   | Deep dive                                                               |
| ---------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------- |
| **Linear** | File and look up engineering escalations without leaving a thread | [Use Linear with Super Magic](/super-magic/use-linear-with-super-magic) |
| **Notion** | Pull runbooks and client docs, write back change logs             | [Use Notion with Super Magic](/super-magic/use-notion-with-super-magic) |
| **Zapier** | Reach thousands of apps through Zapier actions as tools           | [Use Zapier with Super Magic](/super-magic/use-zapier-with-super-magic) |

<Note>
  Connector tools need their own sign-in and inherit the same permission model as every other Super Magic tool — they show up only once connected, and writes still run under your identity with confirmation.
</Note>

## Skills: package a workflow once, run it everywhere

A **skill** is a saved, prompt-first workflow — a proven way of doing a task that anyone can run in Super Magic by name. The [Automation & Flows](/skill-library/automation-and-flows/overview) category is full of them, and the [Connectors](/skill-library/connectors/overview) category shows real skills built on the connectors above. When you have a prompt that reliably does the job, don't leave it in your head — make it a skill.

<Steps>
  <Step title="Prove the prompt by hand">
    Run it in the Super Magic composer until it works every time. A skill is only as good as the prompt underneath it.
  </Step>

  <Step title="Turn it into a reusable skill">
    Use the [Skill Authoring Coach](/skill-library/automation-and-flows/skill-authoring-coach) to shape the prompt into a clean, named skill — clear inputs, defined output, no dependence on one person's context. Keep the instructions **under 3,000 characters**; the coach counts them for you and shows you where to cut.
  </Step>

  <Step title="Wire it to a Flow if it should run itself">
    A Flow that fires Super Magic on a ticket event is a **Super Magic Agent** (Super Magic + Flows). The Flow carries its own **prompt** and a write scope — it doesn't call your saved skill, so paste the proven prompt in and give it only the write tools you're comfortable with it using unattended.
  </Step>
</Steps>

### The 3,000-character limit

Skill instructions and Flow agent prompts are capped at **3,000 characters**. A skill saved before the cap keeps running, but it **can't be saved again** until it's shortened — so the limit shows up the moment you go to edit a long one.

Almost every prompt that's over the line is over because it explains why a step matters two or three times. Say it once, in the imperative, and most drafts land well under.

When that isn't enough, name a **base skill** instead of restating a contract you share with other skills — [PSA Note Discipline](/skill-library/automation-and-flows/psa-note-discipline) for plain-text notes, [Write Guardrails](/skill-library/automation-and-flows/write-guardrails) for confirmation gates, [Connector Degradation](/skill-library/automation-and-flows/connector-degradation) for a missing integration, [Sweep Honesty](/skill-library/automation-and-flows/sweep-honesty) for result caps.

<Warning>
  **Naming a skill only works in Super Magic, not in a Flow.** Working conversationally, Super Magic can reach your other saved skills, so naming one pulls in its contract. A Super Magic Agent fires a prompt with no skill lookup — a name there is just words on the page. Always keep a few words of gloss beside the name so the sentence stands on its own, and for anything a Flow runs, write the rule out in full.
</Warning>

<Warning>
  Don't buy space by deleting a guardrail — a confirmation before a destructive write, a data-loss consent step, an escalation trigger. If a skill can't fit without losing one, it was two skills.
</Warning>

<Tip>
  Mine your own backlog for skill candidates: run the [Automation Opportunity Finder](/skill-library/automation-and-flows/automation-opportunity-finder) against last week's tickets, then author a skill for the pattern that showed up most.
</Tip>

## Automagically: runbooks that execute unattended

For multi-step operational work — the runbooks a technician would otherwise click through by hand — **Automagically** runs the procedure for you. [Automagically getting started](/automagically/automagically-getting-started) is the on-ramp: define a runbook once, and it executes the steps unattended, with the same read-free / write-confirmed discipline the rest of Thread's automation follows.

Reach for Automagically when the work is a *procedure* (a sequence of steps that's the same every time) rather than a *decision* (route this / respond to that). Pair it with your Flows and Intents: the Flow decides *when*, the Intent handles the *conversation*, and Automagically runs the *steps*.

## Where the pieces fit

You now have the full automation toolkit. A quick map of which layer owns what:

* **Flows / status automations** — deterministic routing and state, no code.
* **Intents** — conversational handling of a request type by the Triage Agent.
* **Super Magic skills** — packaged, reusable workflows a person runs by name in Super Magic.
* **Connectors** — extend that reach to external tools over MCP.
* **Thread MCP / API / Rewst** — the same tool layer in your own client or code.
* **Automagically** — unattended execution of repeatable runbooks.

<MarkComplete id="automation-engineer/build-with-super-magic" />

## Next

That's the course. Take a pattern from your own desk and ship it — an Intent, a skill, or a runbook — then come back and browse the full library for the next one.

<CardGroup cols={2}>
  <Card title="Back to your course" icon="rocket" href="/start-here/roles/automation-engineer">
    The hub: your starter kit, build ritual, and FAQ.
  </Card>

  <Card title="Automation & Flows skills" icon="diagram-project" href="/skill-library/automation-and-flows/overview">
    The full Skill Library category built for your role.
  </Card>
</CardGroup>


## Related topics

- [Automation Engineer](/start-here/roles/automation-engineer.md)
- [Thread MCP, the tool reference, and the API](/start-here/roles/automation-engineer/thread-mcp-and-api.md)
- [Super Magic Enablement](/skill-library/training-and-enablement/supermagic-enablement.md)