Most people use Discord like a chat app.

I use it like an operating system.

Not because it’s “fun.” Because it’s the cheapest way I’ve found to run a two-person company (me + an AI agent) with:

  • one shared context
  • one place for decisions
  • one place for deliverables
  • one place for receipts

If you’re building anything solo, the failure mode isn’t “lack of ideas.” It’s context collapse.

You forget what you decided. You lose the thread. You reopen tabs. You rewrite the same notes. You ship slowly.

Discord solves this if you treat it like infrastructure.

The three primitives#

1) Channels are departments#

A channel isn’t a topic. It’s a routing rule.

  • #mission-control: what matters right now
  • #daily-loop: daily plan + daily summary
  • #website-blog: shipping public writing
  • #integration-status: infra changes + receipts
  • #pnl-metrics: numbers or it didn’t happen

The rule: every output has a home.

If it doesn’t have a home, it doesn’t exist.

2) Threads are work items#

Threads beat docs because they naturally preserve chronology.

A thread is a work item with:

  • an ID
  • a status
  • a thesis
  • the next action
  • links/artifacts

The win is not “organization.”

The win is that you can drop back into a thread after 3 days and you’re instantly back in the story.

3) Posts are receipts#

Every time the agent completes a task, it must produce:

  • a Discord post in the correct channel (the deliverable)
  • a receipt (what happened, where it is, how to verify)

This is how you prevent “autonomous hallucination work,” where an agent claims it did something but nothing changed.

Receipts turn autonomy into accountability.

The actual workflow#

Here’s the loop I’m running:

  1. I create tasks with a routing target (which channel to post to).
  2. The agent executes the work.
  3. The agent posts the output + receipt to Discord.
  4. The agent stores a compact memory of what mattered.

Everything else is optional.

The reason this works: Discord is already optimized for high-frequency human collaboration.

Agents need the same thing: a stable place to write, read, and coordinate.

What this replaces#

This setup replaces a mess of tools:

  • Notion (docs)
  • Trello (tasks)
  • Slack (chat)
  • Loom (handoffs)

I’m not saying those tools are bad.

I’m saying Discord is the smallest surface area that still supports:

  • persistent context
  • asynchronous work
  • searchable history
  • low-friction posting

And that matters when you’re trying to move fast on a budget.

The rule that makes it work#

If you only steal one idea:

Every task must end with a public artifact.

A link. A post. A file path. A commit hash. A screenshot. Something verifiable.

If the work didn’t produce an artifact, it wasn’t work.

If you’re building with agents and your projects keep stalling, don’t blame the model.

Blame your operating system.