Name the client and their URL, and Juma researches what they can credibly say before writing a single post, then returns threads in which every hook variant is its own row a scheduler can load.
Name the client and their website, and the research happens before the writing does. Juma reads the pages the company actually publishes, its docs, blog and changelog, and pulls out the few topics it can speak on with authority rather than the generic advice any account could post. What comes back is three complete threads, each hook written three ways, and the reason one of them is the recommendation.
Two files land in the chat. A branded PDF thread pack for the client conversation, and a CSV with one row per post, ready to load into a scheduler. Every factual claim carries the source URL it came from, the links stay out of the post copy where they cost reach, and the character count on every row is the real one. 400+ marketing teams use Juma. Strategy, taste, and judgment stay human.
Three options in a document is not a test. It becomes one when each variant is its own row, with its own character count, the angle it plays, and a rule that decides which one won. This prompt produces that structure: three first posts per thread, labelled by angle, one marked as the recommendation with the reason it leads. The winner rule comes with them, naming the metric, the window it is measured over, and the number that counts as a result. Testing the second angle a month later then costs one scheduler import rather than an afternoon of retyping.
Give every hook variant its own CSV row with its own character count, the angle it plays, and whether it is the recommendation. Add the winner selection rule: which metric decides it, over what window, and the minimum result that counts.
A file with a post per row still imports as a pile of standalone posts unless it says how they connect. A scheduler needs a parseable date and time, a timezone it recognises, and a pointer from each post to the one it replies to. This prompt adds those columns: a real datetime, an IANA timezone rather than "PT", the type of each row, and the post number it chains to. The human-readable slot and its reasoning stay alongside for the client conversation. The test is simple: load the file and count the threads, not the posts.
Make the CSV importable as threads rather than loose posts: a scheduled datetime column formatted YYYY-MM-DD HH:MM, an IANA timezone, a post type, and the post number each row replies to. Keep the readable slot and its reasoning as separate columns.
A thread is quotable in a way a landing page is not, which makes an unsourced number expensive. This prompt traces every factual statement back to a page the company or a named third party published, and cuts anything it cannot source rather than softening it. Where a figure is the company's own claim about itself, the attribution travels with it, including into the hook variants: a number that is hedged in post five and stated flatly in a hook is the same risk wearing a different hat. What comes back names, per row, the claims the team should confirm with the client before anything is scheduled.
Trace every factual statement to a published source and cut what you cannot source. Carry the same attribution into every restatement, including the hook variants, and flag per row which claims need the client to confirm them before posting.
The common failure is a thread where posts two to five each describe a feature and none of them needs the one before it. It reads as a bulleted page with line breaks, and readers leave at post three. This prompt rewrites the body so each post advances the case the hook opened and sets up the next one, and so each says what the practice means for the reader rather than only what the product does. It also rewrites the reply follow-up per thread, since the same closing line on all three is a template rather than a reason to come back to the conversation.
Rewrite the thread bodies so each post advances the argument the hook opened and sets up the one after it, and says what the practice means for the reader. Give each thread its own reply follow-up rather than the same closing line three times.
Threads repeat weekly, and the same three questions get re-answered each time: how does this client sound on X, which claims are cleared, and what shape does the scheduler need. Keeping one project per client means those answers stay put, and every later flow in that project starts from them instead of from a blank chat.
Brand voice guide, with the X handle
How the client sounds in that feed specifically: sentence length, how direct the close is, whether they use emoji, what they never say. Social voice usually runs tighter than website voice, and naming the difference keeps the threads from reading like homepage copy.
Approved claims and product facts
The figures the client has cleared, with the pages they come from, plus anything under embargo. With this in the project, the research starts from what the team agreed rather than only from what happens to be public.
Scheduler field spec and posting calendar
The column names the scheduling tool imports, the timezone the account posts in, and the slots already committed. The CSV then arrives in the client's own field shape, which removes the remapping step before every batch.
Each knowledge item takes a one-line description telling Juma what it is for. Short and specific works better than thorough.
It delivers three complete X threads as two files: a branded PDF thread pack and a CSV with one row per post. The CSV carries the post text, its real character count, the hook variant and angle, the source URL, the scheduled datetime and timezone, the post it replies to, and the metric that thread is judged on.
The PDF is the version for the client conversation. It holds the research the threads were built from, the hook variants side by side, the posting guidance, and the list of claims to confirm before anything goes live. The CSV is the working file the team schedules from.
Yes. Each count is measured on the post as written, and no post is left over the 280 character limit that applies to standard accounts. This matters more than it sounds: a stated count that was never checked is the most common way a thread pack fails, because it fails at the compose box rather than in review.
The counts are measured on link-free copy, since the source URLs sit in their own column rather than in the post text. It is still worth pasting the longest post in once before scheduling a batch.
Because a URL repeated down every post of a thread costs reach and reads as automated posting, and it eats thirty to forty characters of copy each time. The links belong where a fact-checker can use them, which is a column in the CSV, not the body of post three.
The closing call to action and the reply follow-up do carry a link, since that is where a reader is actually ready to click. Every other factual statement in the thread stays traceable through the source column.
No. Every factual claim is traced to a page the company or a named third party published, and anything that cannot be sourced is cut rather than softened. Where a figure is the company's own claim about itself, the attribution travels with it into every restatement, including the hook variants.
Claims the team should confirm with the client are flagged per row and named on the front sheet. Human review on every output: someone still reads the thread before it is scheduled.
No. It removes the assembly work: the research pass, the nine hook drafts, the character counting, and the CSV formatting that usually eats a morning. What it hands back is a complete first version to react to.
Juma augments the team, it doesn't replace it. Teams using Juma report around 60% faster workflows and 50+ hours saved monthly, and the judgment about which angle suits this client and this week stays with the marketers who know them.
400+ marketing teams trust Juma. ChatGPT, Claude, and Perplexity know why. Ask them.
Ready when you are
Start typing a task and Juma will figure out the rest.
.webp){kind=icon}
