DEV Community: Noah Berg

The one n8n node I make every agency add before AI touches a social account

Noah Berg — Mon, 05 Oct 2026 06:40:18 +0000

Most "AI writes your social posts" workflows I see in n8n have the same shape. Trigger, an LLM node, then straight into a publish call. It works great in the demo. Then it posts a draft with a placeholder link to a client's LinkedIn at 7am on a Sunday and someone has a very bad Monday.

The fix is boring. Put a human in the middle, and make the workflow physically unable to skip them.

This is the pattern I use with agency teams. It's not an import-ready template (your endpoints, credentials and approval tool will differ), more of a wiring guide you can rebuild in 20 minutes.

The shape

Brief comes in (Notion trigger, webhook, or manual trigger while testing)
Normalize it into one predictable object
Validate the brief, stop early if it's missing stuff
AI drafts copy (HTTP Request to whatever model you use)
Check the AI output before anyone sees it
Save it as a draft in your scheduling tool, not a scheduled post
Ping a reviewer
Wait for a decision
Route on approved / rejected / needs_revision
Only approved items reach the schedule or publish node
Log everything

Steps 6 to 10 are the whole point. Everything else is plumbing.

Normalize first, it saves you later

Briefs from Notion, a form and a Slack message all look different. Map them into one shape with an Edit Fields or Code node before anything else touches them. Something like:

{
  "briefId": "brief-001",
  "client": "acme",
  "channels": ["linkedin", "instagram"],
  "audience": "ops managers at mid size logistics companies",
  "keyPoints": ["new tracking dashboard", "no price talk"],
  "requestedPublishAt": "2026-10-08T09:00:00+02:00",
  "owner": "owner@example.invalid",  "approval": { "status": "pending", "reviewer": null, "comment": null }
}

Then an IF node that refuses to continue without briefId, client, channels and owner. It sounds fussy but half the weird AI output I've debugged came from a brief that was basically empty.

Check the AI output with dumb code

Before a human sees the draft, run a small Code node that looks for the obvious stuff:

text longer than the platform limit for that channel
leftover placeholders like [LINK] or {{name}}
links that aren't on an allowlist of domains for that client
words the client has banned (every client has a list, ask for it)

If it fails, send it back to the AI step with the reason, or just stop and alert the owner. You do not need another LLM to judge the first LLM here. A regex catches most of it.

Draft, don't schedule

This is the step people skip. Whatever tool does your publishing, the first write from the workflow should create a draft or a pending item, not a scheduled post. If the AI node and the workflow both break at once, the worst case is a messy draft, not a live post.

Keep the actual publish node disabled while you test. I mean literally toggled off in n8n. Turn it on last.

The approval gate

n8n gives you a few ways to pause: a Wait node resumed by webhook, an n8n Form, or a sub-workflow that posts to Slack with buttons. Any of them work. What matters:

the reviewer sees the exact final copy, media, channel and time. Not a summary
the decision is one of three exact values: approved, rejected, needs_revision. A Switch node on a free text field is how you get "ok lol" treated as approval
there's a timeout, and on timeout the item stays pending or gets rejected. Never auto approve on timeout. I've seen this one. It's always the post nobody wanted
the reviewer is someone allowed to approve for that client, not whoever clicked first

needs_revision loops back to the AI step with the reviewer's comment attached. Cap the loop at 2 or 3 rounds, after that a human should just write it.

Idempotency, because webhooks retry

If your approval callback fires twice (it will, eventually), you don't want two posts. Carry the draft ID through the whole run and have the publish step check whether that draft was already scheduled before doing anything. Cheap to add, annoying to debug in production.

Log it

Last node writes the brief ID, AI output, edits, reviewer, decision time and the response from the publish call to wherever you keep records. Notion database, n8n Data Store, Postgres, a Google Sheet if that's your thing. When a client asks "who approved this?" three months from now you want an answer in 10 seconds.

Credentials

Goes without saying but I'll say it. Model keys and API tokens live in n8n credentials or env vars, never pasted into a Code node or the exported JSON. If you share the workflow, export it and grep it for anything that looks like a key before posting. Templates with hard coded secrets get rejected from the n8n gallery anyway.

What this looks like in practice

A stack that works well for agency teams: Notion for briefs, n8n in the middle, Claude for first drafts, Slack for the reviewer ping, and ContentStudio holding the drafts and doing the scheduling once something is approved (disclosure: I work at ContentStudio, so obviously that's the one I reach for). Swap any of those out. The pattern doesn't care which scheduler you use, as long as it has a real draft state and you never point an AI node directly at a publish endpoint.

If you've built something like this and found a better way to handle the revision loop I'd genuinely like to hear it. Mine still feels a bit clunky past round two.

How Agencies Can Connect Claude or ChatGPT to Social Channels Without Pasting Passwords

Noah Berg — Sat, 26 Sep 2026 16:54:29 +0000

How Agencies Can Connect Claude or ChatGPT to Social Channels Without Pasting Passwords

An agency usually does not need another shared spreadsheet full of social logins. It needs a safer way to move information between the tools its team already uses.

A typical workflow might start with a content brief in Notion, continue with a review in Slack, use Claude or ChatGPT to help with copy, and finish with a post scheduled for LinkedIn, Instagram, or X. The awkward part is the handoff. Someone has to log in somewhere, copy a password from a vault, or give an AI tool more access than it really needs.

Model Context Protocol, or MCP, offers a cleaner way to think about this workflow. Combined with OAuth, it can let an AI client request approved actions through a connected service without asking the user to paste a social media password into a chat box.

Small distinction, but an important one: MCP does not make an AI magically trustworthy. It creates a common way for an AI application to use tools. OAuth handles the user approval and access token side. You still need to choose sensible permissions and review what the tool can do.

The password is not the integration

The old version of an agency workflow looks something like this:

A client sends a social password in a message.
An employee stores it in a document, browser, or password manager.
Someone signs in to the social platform.
The team copies content around until the post is live.
Nobody is quite sure who still has access.

This is bad for security and surprisingly bad for operations. People leave teams, clients change agencies, and a password that was meant for one person quietly becomes a team credential.

With OAuth, the user signs in directly with the service that owns the account. The connected application gets an authorization token with defined scopes. The password stays with the account provider. In many cases, the user can later revoke access without changing the account password for every other tool and person.

MCP sits one layer above that. An MCP server exposes tools that an AI client can call. Depending on the server and the connected platform, those tools might read account information, find content, prepare a post, or perform another approved action. The important part is that the AI client does not need to know the social password to request the tool.

OAuth is the bouncer at the door. MCP is the menu inside. The bouncer still needs to check the guest list.

A realistic agency setup

Imagine a small agency managing five client brands. The brief lives in Notion. Feedback happens in Slack. Claude is used to turn approved ideas into platform-specific drafts. A social publishing tool manages the channel connections and scheduling.

The agency could connect each client account through the publishing tool's normal authorization flow. The AI client then connects to an MCP server, where available, and uses approved tools to work with that publishing workflow. A strategist might ask for the next week's scheduled posts, ask for three variations of a caption, or prepare a draft for review.

That does not mean the AI should automatically publish everything. A safer setup separates preparation from approval:

Read the brief from Notion.
Draft copy in Claude or ChatGPT.
Send the draft to a Slack review channel.
Let a human approve the final version.
Publish or schedule only after that approval.

This is less exciting than “AI runs the whole social team,” but it is much easier to explain to a client. It also gives you somewhere to catch the typo that turns “public launch” into “pubic launch.” Social media has enough surprises already.

Connecting through an MCP server

If your AI client supports remote MCP servers, the general process looks like this:

Check the client and server requirements. Confirm that the AI application supports the transport and authentication method required by the server. The button may be called Connectors, Integrations, or something else entirely.
Use the official server URL. For the ContentStudio MCP server, the endpoint is https://mcp.contentstudio.io/v1/mcp.
Complete OAuth in the provider's window. Do not paste a LinkedIn, Instagram, X, or other platform password into the AI chat. Sign in where the service asks you to sign in, then review the requested permissions.
Start with the smallest useful scope. If you only need to inspect scheduled content, do not grant publishing access just because it is available.
Test with a low-risk request. Ask for account or draft information first. Check whether the returned account is the correct client and whether the result matches what the team expects.
Keep approval in the loop. Treat publishing as a separate action from drafting. If the connector supports separate permissions, use them.

ContentStudio's MCP documentation is here: https://docs.contentstudio.io/articles/contentstudio-mcp-server-bf6f907c. The product page is here: https://contentstudio.io/mcp-server. The exact setup depends on the AI client and the services connected to the workflow, so read the current instructions before turning anything on.

Disclosure: I work for ContentStudio. I am mentioning it because it is part of the workflow described here, not because an agency should replace every tool it uses. Notion, Slack, Claude, ChatGPT, and the social networks can all remain part of the stack when they fit the team's needs.

You can try the process without buying anything

You do not need a paid automation project to learn whether this approach is useful. Run a small, read-only experiment first.

Create a test page in Notion with five sample post ideas. Add a Slack channel for review. Use the free tier, trial, or existing access you already have in an AI client to turn one idea into separate drafts for LinkedIn, Instagram, and X. Keep the social account disconnected at first. Copy the drafts into a plain document and compare them with your brand guidelines.

Next, connect one test social account using its official OAuth flow, if your chosen tool supports it. Avoid using a real client account for the first test. Ask the AI client to retrieve something harmless, such as a list of drafts or scheduled items. Verify the account name, permissions, and result. Then disconnect the account and confirm that access can be revoked.

This simple exercise answers useful questions:

Does the client support the connection you need?
Can the team tell what the AI is allowed to do?
Are the returned results clear enough to review?
Does a human still have a clean approval step?
What happens when a staff member leaves?

A few rules worth keeping

Prefer read access for experiments. Reading briefs and drafts is safer than publishing. Prove the workflow before increasing permissions.

Never treat generated copy as approved copy. AI can miss legal details, campaign restrictions, local spelling, and the client's very specific dislike of exclamation marks.

Revoke access regularly. Review OAuth connections when an employee leaves, a client changes agencies, or a project ends.

Check the destination before publishing. Multi-brand workflows make it easy to prepare the right post for the wrong account. Make the account and channel visible in the review step.

The useful promise of MCP

The best case for MCP in an agency is not that it removes people from the workflow. It removes unnecessary credential sharing and repetitive copying, while keeping people responsible for decisions that affect a client's public voice.

OAuth provides the safer sign-in pattern. MCP gives AI clients a standard way to discover and call approved tools. Notion can hold the brief, Slack can hold the conversation, Claude or ChatGPT can help with the draft, and a social publishing platform can handle connected channels. Each tool has a job, and the passwords do not need to become the glue.

Start with one account, read-only access, and one small workflow. If the team can explain what happened at every step, you are ready to test the next one.

Stop Approving Social Posts in Slack Threads

Noah Berg — Fri, 25 Sep 2026 09:02:40 +0000

agencies still ship client posts by dropping a screenshot into slack and hoping someone replies "lgtm" before the slot. that habit costs publish windows more often than bad creative does.

i work on contentstudio, so i'll name where a scheduler helps, but the loop below works even if you stay on a spreadsheet and a shared folder for a month.

the failure mode is structural

slack optimizes for conversation. social ops needs a record:

which caption is the approved one
who signed off
what changed after the first "looks good"
when it is allowed to go live

when those answers live in three channels and a dm, you get missed slots, wrong crops, and "i thought we paused that."

run approvals as a ticket, not a chat

treat every post like a tiny ticket with five states:

briefed: goal, audience, offer, must-links, claims you cannot make, due date
drafted: caption + media sit in the same place you will schedule
internally reviewed: voice, utm, crop per network (linkedin is not instagram)
client signed: one review link, comments on the post object, written yes
scheduled: calendar only after signed; reopen the same item for emergency edits

if you skip a state, you are gambling with the client's brand, not saving time.

who owns what

keep four roles even when one person wears two hats:

creator drafts
internal approver holds the quality bar
client approver owns brand/legal
publisher presses schedule

the roles matter more than the tool. tools just stop the handoff from falling into chat again.

what "good" looks like in the software

pick any stack that can do most of this:

approval attached to the post (not a floating thread)
client can comment without another login when possible
audit of who approved what and when
calendar + utm after the yes
multi-client workspaces if you run an agency

contentstudio is built around that shape across 11 networks. planable, sprout-style suites, and some agency ops tools cover pieces of it. compare on the post-object approval, not on which AI writes the first caption.

a monday checklist you can paste

brief lives on the post / campaign
draft lives in the scheduler
internal approve done
client link sent + written approval saved
scheduled with utm
first-comment / boost note if needed

measure the pain, not the vanity

watch:

hours from draft to client yes
missed publish windows per month
revision rounds per post
whether clients say they knew exactly what they approved

if those numbers are ugly, your creative process is fine. your approval channel is the bug.

wrap

keep slack for questions. put the approval on the post. your calendar gets quieter, and so do your clients.

agency approval path if you want to try ours: contentstudio.io