{"slug": "building-quill-a-slack-ai-blog-agent-with-astro", "title": "Building Quill: A Slack AI Blog Agent with Astro", "summary": "Postman DevRel engineer built Quill, a Slack AI blog agent using Astro, that automates the full content pipeline from topic submission to staged WordPress draft, handling research, drafting, copy-editing, Confluence saves, Jira ticket creation, and scheduling. The agent separates deterministic workflows (API calls, scheduling) from non-deterministic LLM calls (drafting, editing, idea generation) using isolated Claude API calls with dedicated system prompts.", "body_md": "# Building Quill: A Slack AI Blog Agent with Astro\n\n*From Slack message to staged blog post — research, draft, edit, and all. Here’s how I designed and deployed Quill, and what I learned about building agents that actually ship in production.*\n\n## The problem I was trying to solve\n\nOur DevRel team publishes content regularly: blog posts, tutorials, announcements. The process was always the same. Come up with an idea, research it, write a draft, copy-edit it, get a header image ticket into Jira, save the draft to Confluence so others can review it, then eventually stage it to WordPress. Four or five tools, a lot of context-switching, and plenty of things that could fall through the cracks.\n\nI wanted to build an agent that could handle the whole pipeline. You drop a topic in Slack, Quill does the rest: research, draft, copy-edit, save to Confluence, open a Jira ticket for a header image, and stage to WordPress as a draft, ready for a human editor to schedule and publish.\n\nThat agent is Quill. This is the story of how I built it.\n\n## The first design question: what should the AI decide vs. what should be hardcoded?\n\nBefore writing a single line of code, I had to think through one of the most important questions in agent design:\n\n**What parts of this workflow should be deterministic, and what parts should be non-deterministic?**\n\nIf you’re new to agents, here’s a simple way to think about it:\n\n- Deterministic workflows always produce the same output for the same input. They’re predictable, auditable, and easy to test. Think: saving a file, creating a Jira ticket, scheduling a post on a specific date.\n- Non-deterministic workflows use an AI model to generate output that varies based on context, creativity, and the prompt. Think: writing a blog post, brainstorming ideas, copy-editing for tone.\n\nGetting this split right is what separates an agent that actually works in production from one that surprises your team in bad ways.\n\n### Quill’s deterministic workflows (the “just do it” parts)\n\nThese are the parts where I did *not* want the AI improvising:\n\n- Saving to Confluence. Always saves to the same space, same parent page. No creativity needed.\n- Creating a Jira ticket. Always creates in the marketing project, always tagged as a header image request, always links back to the Confluence draft.\n- Staging to WordPress. Always creates a draft, never publishes. Predictable, auditable, reversible.\n- Finding the next available publish slot. Pure scheduling logic: Tuesdays and Thursdays at 8am PT, skip US holidays, one post per day. No LLM needed here at all.\n- Checking blog coverage. Searches blog.postman.com to see if a topic has already been covered. A yes/no lookup.\n\nThese are API wrappers that run consistently. If something goes wrong, it’s easy to trace the cause. Trading for a deterministic workflow means you don’t waste tokens or money on unnecessary LLM calls.\n\n### Quill’s non-deterministic workflows (where the AI earns its keep)\n\nThese are the parts where an LLM actually adds value:\n\n- Writing a draft. Quill calls Claude with a dedicated system prompt that encodes Postman’s voice, banned words, SEO requirements, and target length (1,200 to 1,600 words). The output will differ each time, and that’s by design.\n- Copy-editing. Another dedicated Claude call with a style guide and SEO pass. Returns auto-applied changes and flags risky rewrites for a human to review.\n- Blog idea generation. Parallel web searches across multiple signals, scored against five weighted criteria. Eight to twelve ideas, ranked by urgency.\n\nEach of these tools makes its *own* isolated Claude API call with its own system prompt. I didn’t route everything through a single mega-prompt. That would have made the behavior harder to control and harder to debug.\n\n## Planning the APIs\n\nOnce I knew what the agent needed to do, I mapped out the integrations. Here’s the dependency chain I was working with:\n\n| Integration | What Quill uses it for |\n|---|---|\n| Anthropic API | Write draft, copy-edit, generate ideas (three separate Claude calls) |\n| Tavily | Web search for research and coverage checks |\n| Confluence REST API | Save drafts, read existing pages |\n| Jira REST API v3 | Create header image tickets in the Marketing project |\n| WordPress REST API | Stage posts as drafts, read editorial calendar |\n| Slack (via Astro) | Surface as a chatbot the team can talk to |\n\nOne useful decision: I used a single shared Atlassian service account for both Confluence and Jira. One API token, one identity, write access to the drafts space and create-issue permission on the marketing project. This keeps the auth surface small.\n\n## Testing the non-deterministic parts with Postman AI Request\n\nAt the heart of Quill are three core tools: `blog_ideas`\n\n, `blog-write`\n\n, and `copyedit_draft`\n\n. Before wiring everything together, I needed to validate the skills and system prompts behind each one.\n\nThis is where Postman’s AI Request was really useful. I used it to test my Anthropic API calls in isolation before embedding them in the agent. The workflow looked like this:\n\n- Write the system prompt for\n`blog-write`\n\n: Postman voice, banned words, SEO frontmatter, 1,200 to 1,600 word target. - Run it against a dozen different blog topic inputs in Postman to see how the output varied.\n- Identify patterns where the model drifted from the style guide.\n- Iterate on the prompt until the outputs were consistently in the right range.\n- Repeat for\n`copyedit_draft`\n\nand`blog_ideas`\n\n.\n\nThe key insight from testing non-deterministic workflows: you’re not testing for a single correct answer. You’re testing for a range of acceptable answers. Postman made it easy to save these prompts so you can reuse them in the future to evaluate changes, pick a different model when Anthropic announces one, and run them at volume to spot when the model starts drifting in the wrong direction.\n\nNote:Testing deterministic tools is easy. Did it create the Jira ticket? Did it save to Confluence? Pass/fail. Testing non-deterministic tools is more like reviewing a sample of outputs and asking: “Would I be comfortable if my team saw this?” That’s the bar.\n\n## Building locally with Astro AI\n\nOnce the prompts were solid, I scaffolded the agent using [Astro AI](https://astropods.com). Astro AI is the platform I used to deploy Quill into production, but it also gives you a clean, opinionated starting point on day one.\n\n### Scaffold the project\n\nA new agent is one command:\n\n```\nast project create my-agent --model anthropic\n```\n\nThe generated harness includes starter source code, an `astropods.yml`\n\nblueprint, and two files that describe the project to coding agents:\n\n`AGENTS.md`\n\nexplains the project structure, the spec format, and the conventions for writing a proper Astro Pods agent. Any coding agent (Claude Code, Copilot, Cursor, and so on) can read this to understand how to implement and extend your agent correctly.`CLAUDE.md`\n\ncontains Claude Code-specific instructions for working in this project.\n\nTogether, these two files mean you can hand the repo to a coding agent and it already knows the house rules. That’s a big deal when you’re iterating fast.\n\n### Configure your agent for local development\n\nNext, set the credentials and API keys your agent needs (Anthropic, Tavily, WordPress, Confluence, Jira, and so on):\n\n```\nast project configure\n```\n\nThis walks you through each required env var and stores them so both local runs and production deploys pick them up.\n\n### Run your agent locally\n\nStart the local development environment:\n\n```\nast project start\n```\n\nThe agent boots in a local container. I could talk to Quill in the local playground, watch the tool calls fire, and fix things before ever touching production.\n\n### The astropods.yml file\n\nThe `astropods.yml`\n\nfile is the blueprint for the whole agent. It’s what Astro uses to understand what the agent is, what it needs, and how to deploy it. It declares the runtime, the env vars Astro should inject (Anthropic, Tavily, WordPress, Confluence, and Jira credentials), the adapters (Slack and web), and the list of tools Quill exposes: everything from `web_search`\n\nand `check_blog_coverage`\n\nthrough the three Claude-backed tools (`write_draft`\n\n, `copyedit_draft`\n\n, `blog_ideas`\n\n) to the Confluence, Jira, and WordPress integrations.\n\nThat file is the single source of truth. Astro reads it and knows exactly what to provision, what secrets to inject, and how to expose the agent (in this case via Slack and a web interface). There’s no infrastructure YAML to manage separately.\n\n## Pushing to a blueprint and deploying\n\nOnce local testing was solid, shipping Quill was two commands.\n\nFirst, push the local project up as a blueprint:\n\n```\nast blueprint push quill\n```\n\nThen deploy it:\n\n```\nast blueprint deploy\n```\n\nFrom there, I connected Slack in the Astro dashboard: deployed agent, Integrations, Slack, connect workspace. Anyone on the team could now drop a message to Quill in Slack and the whole pipeline was live.\n\nYou can see the full blueprint, including the repo layout and architecture, at [astropods.com/postman/quill](https://astropods.com/postman/quill). If you want to deploy your own version, there’s a one-click deploy button right on that page.\n\n## What I can see now that it’s running\n\nThis is the part I underestimated before I started: observability matters enormously for agents in production. When Quill goes sideways, and it does sometimes, I need to know exactly where and why.\n\nAstro gives me tracing out of the box. Here’s what I actually look at:\n\n- Token usage. Prompt vs. completion tokens, per request and over time. Useful for spotting when a prompt is ballooning unexpectedly, and for forecasting API costs as usage grows.\n- Tool calls. Which tools fired, what they returned, and where they failed. This is the most important one. If\n`save_to_confluence`\n\nreturned a 403, I can see that immediately. If`write_draft`\n\nproduced something short, I can see the raw Claude response. - Latency. End-to-end and per span. Writing a draft takes the most time (LLM call plus long output). Saving to Confluence is nearly instant. This breakdown helps me know what’s actually slow vs. what just feels slow.\n- Request volume. Traffic patterns and error rates over time. How often is the team using Quill? Which requests fail most often?\n- Network traffic. Payload sizes across every external call. Useful for catching cases where Quill is sending way more data to an API than necessary.\n\nIf you’re building agents and you’re not tracing them, you’re debugging in the dark. An agent with 12 tools and 3 LLM calls has a lot of surface area for things to go wrong. Tracing is what turns a mystery into a five-second diagnosis.\n\n## What I’d tell someone starting today\n\nA few things I wish I had internalized earlier — one of them I almost didn’t include because it sounds like a product pitch, but it genuinely changed how fast I could ship:\n\n- Separate your deterministic and non-deterministic workflows early. The clearer that line is, the easier everything else becomes: testing, debugging, building trust with your team.\n- Give each LLM tool its own system prompt. Don’t route everything through a single prompt. Isolated prompts are easier to test, easier to tune, and easier to reason about when something goes wrong.\n- Test your prompts before you embed them. Use Postman’s AI Request (or something like it) to run your prompts at volume and validate the range of outputs before wiring them into the agent.\n- Use a platform that handles the infrastructure. Astro AI let me focus on what Quill actually does rather than how to containerize it, manage secrets, and wire up Slack. That’s not yak-shaving I wanted to do.\n- Ship with observability from day one. Don’t add it later. You’ll want it the first time something breaks in production and your team is waiting on you.\n\nQuill is a teammate and this blog is written by both myself and Quill.\n\nThat’s genuinely how I think about it. Quill joined our team, picked up the blog workflow, and just got to work. Every time someone drops a message in Slack, Quill turns it into a staged draft without anyone touching four different tools. It has already saved us hours per post.\n\nWe’re still training it. There’s more we want to teach it about how we work, and persistent memory across sessions is coming. But that’s true of anyone new to the team. You don’t wait until someone is fully onboarded to let them add value.\n\nWhat makes Quill easy to trust is that we can check its work and coach it when something’s off. It’s not a black box. It’s a teammate who’s still learning, but who shows up every single time.\n\nIf you want to bring Quill onto your team, the blueprint is public at [astropods.com/postman/quill](https://astropods.com/postman/quill).\n\n## Resources\n\n- Quill blueprint on Astro AI:\n[astropods.com/postman/quill](https://astropods.com/postman/quill) - Astro Pods documentation:\n[docs.astropods.com/welcome](https://docs.astropods.com/welcome) - Explore other agent blueprints:\n[astropods.com/explore](https://astropods.com/explore) - Postman AI Agent Building:\n[postman.com/product/ai-agent-building](https://www.postman.com/product/ai-agent-building/) - Anthropic Claude API documentation:\n[docs.anthropic.com](https://docs.anthropic.com/)\n\n*Built with Astro AI, Anthropic Claude, Postman AI Request, and Mastra.*", "url": "https://wpnews.pro/news/building-quill-a-slack-ai-blog-agent-with-astro", "canonical_source": "https://blog.postman.com/building-quill-a-slack-ai-blog-agent-with-astro-pods/", "published_at": "2026-07-27 16:03:18+00:00", "updated_at": "2026-07-27 16:39:22.828903+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-agents", "generative-ai", "developer-tools"], "entities": ["Postman", "Quill", "Slack", "Astro", "Anthropic", "Claude", "Confluence", "Jira"], "alternates": {"html": "https://wpnews.pro/news/building-quill-a-slack-ai-blog-agent-with-astro", "markdown": "https://wpnews.pro/news/building-quill-a-slack-ai-blog-agent-with-astro.md", "text": "https://wpnews.pro/news/building-quill-a-slack-ai-blog-agent-with-astro.txt", "jsonld": "https://wpnews.pro/news/building-quill-a-slack-ai-blog-agent-with-astro.jsonld"}}