Using Firecrawl and Kiro to Build Your Own Writing Style Steering Guide

One of the quieter superpowers of working with an AI assistant is consistency. Not just "it gives me good answers" consistency, but "it sounds like me" consistency. That's harder to achieve, and it's what this article is about.

I recently had a conversation with Kiro, Amazon's AI-powered IDE, that turned into something I didn't plan: a mostly automated pipeline that scraped my own published articles, extracted my writing style from them, and encoded it into a reusable instruction file that now shapes every article I write with AI assistance.

Here's how it works, and how you can do the same.

The Problem: AI Writes in Its Voice, Not Yours

If you've ever asked an AI to help you write a blog post, you know the result: somewhat technically correct, well-structured, and completely devoid of your personality. The AI doesn't know you open with a specific kind of hook, that you always include a cost section, or that you make bad golf analogies when explaining scoring systems.

You can fix this behaviour if you teach the tool about you once, and let it apply that knowledge automatically.

The Solution: A Steering File Backed by Your Own Writing

Kiro supports a concept called steering files: Markdown documents stored in your workspace under .kiro/steering/ that can be injected into your conversations. Think of them as persistent project-level instructions that travel with your workspace.

The idea is simple:

1. Scrape your published articles
2. Save them locally
3. Have Kiro analyze them and extract your writing style
4. Store the result as a steering file

After that, every time you work with Kiro, your style can already be in context.

What Is Firecrawl?

Firecrawl is a web scraping and crawling API designed specifically for extracting clean, structured content from web pages. Unlike raw HTML scrapers, Firecrawl returns Markdown, which is exactly what you want when feeding content to an LLM. It can handle JavaScript-rendered pages, cookie banners, and navigation boilerplate, giving you the article text instead of a soup of HTML and menu items.

You can make Firecrawl available to Kiro as an MCP tool, so you can invoke it directly from chat without writing a single line of scraping code.

Step-by-Step: Building Your Writing Style Guide

Prerequisites

• Kiro installed and running
• A Firecrawl account
• Node.js/npm available locally, because the Firecrawl MCP server is launched with npx
• A handful of published articles you've written; URLs are enough

(0) Gather Your Article URLs

Find 5-10 articles you've written that represent your best and most typical work. Mix long tutorials with shorter opinion pieces if you have them. The more variety, the richer the style profile.

In my case, I grabbed a set of articles I'd published on the AWS Builder Center:

<https://builder.aws.com/content/37wH59HnFxsrGkGbleb4q3ZaKh6/providing-ai-agents-real-time-factual-knowledge-with-valyuai-and-amazon-bedrock-agentcore>
<https://builder.aws.com/content/2yX8TtxT5MeriKgvebas4LSvGfL/deploying-n8n-on-aws-in-under-5-minutes>
<https://builder.aws.com/content/2uFvyCPQt7KcMxD9ldsJyjZM1Wp/model-context-protocol-mcp-and-amazon-bedrock>
<https://builder.aws.com/content/2dtxFWtVIu7OKI06g9fxE6tvHyV/automate-sustainability-of-aws-infrastructure-with-sustainability-scanner>
<https://builder.aws.com/content/2dteGiv4oBkmNVvEIX7fWLmfPpu/analysis-paralysis-get-unstuck-with-aws-decision-guides>
<https://builder.aws.com/content/2d1B5srtVqbVYnlm9ixKNJf4p1M/serverless-retrieval-augmented-generation-rag-on-aws>

(1) Configure Firecrawl MCP in Your IDE

Right out of the box, when you create a Firecrawl account, you get an API key, and that key is what lets Kiro call Firecrawl through MCP.

Open your Kiro MCP configuration at.kiro/settings/mcp.json, but your local setup may vary depending on how you manage Kiro settings.

Add a Firecrawl server entry under mcpServers:

{
  "mcpServers": {
    "firecrawl-mcp": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "${FIRECRAWL_API_KEY}"
      }
    }
  }
}

Then set the environment variable in your shell before starting Kiro.

On macOS or Linux:

export FIRECRAWL_API_KEY="your-firecrawl-api-key"

On Windows PowerShell:

$env:FIRECRAWL_API_KEY = "your-firecrawl-api-key"

For a quick local demo, you can paste the key directly into the MCP config, like this:

"env": {
  "FIRECRAWL_API_KEY": "YOUR-API-KEY-HERE"
}

But please treat that as training wheels. The API key is sensitive information. Do not commit it, do not paste it into screenshots, and do not push it to a public repository.

Kiro may also ask you to approve the environment variable before it expands it inside MCP configuration. That's a good thing. It prevents MCP servers from casually reading arbitrary environment variables on your machine.

Once the server is configured, reload the MCP servers or restart Kiro.

A good smoke test is simply:

"Can you see the Firecrawl tools?"

If Kiro can see them, you're ready to scrape.

(2) Scrape and Save the Articles

Paste your URLs into Kiro and ask it to scrape and save them. Kiro can call Firecrawl for multiple URLs instead of forcing you to copy-paste pages by hand.

My prompt was simply:

"Can you scrape and download the following? [paste URLs]"

Kiro scraped the articles and saved each one as a Markdown file under an articles/ folder in my workspace. The files came back clean: just the article content, no cookie banners, no navigation clutter, no lovingly preserved footer links from 2019.

This is especially useful for pages that are rendered as single-page applications. As I am using AWS Builder Center content for this example, a simple fetch will struggle because the useful article body is rendered dynamically. Firecrawl handles that retrieval step and gives Kiro something it can actually reason over.

(3) Ask Kiro to Analyze Your Writing Style

Once your articles are saved locally, ask Kiro to read them and produce a writing style guide:

"Can you read those articles and create a steering file describing my writing style? I want it to be applied to future articles I'll write with Kiro."

Kiro reads all the files and looks for patterns across them:

• How you structure articles: hook -> problem -> solution -> walkthrough -> cost -> resources
• Your tone: warm, direct, first-person, lightly self-deprecating
• Formatting conventions: H2/H3 hierarchy, bold bullet leads, zero-indexed steps
• Language patterns: rhetorical questions for definitions, analogies for complex concepts
• What you consistently avoid: hype language, passive voice, missing cost sections

The output is a detailed Markdown document: a proper style guide, not just a vibe check.

(4) Store It as a Steering File

Kiro saved the result to .kiro/steering/article-writing-style.md with an inclusion: always front-matter flag. This tells Kiro to inject the file into every conversation automatically.

The steering file structure looks like this:

---
inclusion: always
---

# Giuseppe Battista - Writing Style Guide

## Audience
...

## Tone & Voice
...

## Article Structure
...

## Formatting Conventions
...

## Things to Avoid
...

From this point on, every article you draft with Kiro can start from your voice, not a generic AI voice.

(5) Rename It to Something Explicit

Kiro initially saved the file as writing-style.md. One more prompt:

"Can you rename it so it's explicit that this is for articles?"

One command later: article-writing-style.md. Small thing, but it matters when you start accumulating multiple steering files for different contexts.

(6) Switch It to Manual Inclusion

Kiro defaulted the file to inclusion: always. That's fine for a first pass, and it makes the demo very satisfying because the style guide immediately affects the next writing task.

But for real work, I prefer manual inclusion for writing style guides.

Why? Because you will probably end up with more than one voice profile:

• Technical articles
• LinkedIn posts
• Executive emails
• Internal strategy docs
• Monthly business reviews
• Customer follow-ups

Those should not all be active all the time. If every style file is always included, your assistant starts mixing contexts. You ask for an executive email, and it may bring in the full "technical article with implementation details and cost table" energy. Sometimes that is useful. Sometimes it is how you accidentally write a novel to someone who asked for three bullet points.

So change the front matter from this:

---
inclusion: always
---

To this:

---
inclusion: manual
---

Now you decide when to include it. When you want Kiro to use that specific guide, pull it into the conversation through Kiro's steering/slash-command workflow, or explicitly tell Kiro to use .kiro/steering/article-writing-style.md for the draft.

A good prompt looks like this:

"Use my article writing style steering file and draft an article titled Using Firecrawl and Kiro to Create Your Own Writing Style Guide."

After the steering file exists, Kiro uses it to draft a new article about the workflow we just built. Very pleasing little loop. This article is the evidence that the system works.

What the Style Guide Captures

After analyzing six of my articles, Kiro identified these consistent patterns:

Structure: Every article opens with a hook, moves through problem -> solution -> implementation -> economics -> resources. The walkthrough section often uses zero-indexed bold steps like (0), (1), (2).

Tone: First-person, warm, direct. Jokes are welcome but not forced. No hype. Opinions are stated clearly and backed by evidence: load test numbers, cost tables, customer quotes.

Formatting: Bold + bullet lists for features. Arrows for process flows. Blockquotes for impactful quotes. Tables for cost comparisons. Clear security notes when keys, credentials, or permissions are involved.

Content philosophy: Founder-first framing, show-don't-tell, open source where possible, always end with actionable next steps.

Things to avoid: "revolutionary", "game-changing", passive voice, missing cost sections, generic intros.

It's surprisingly specific, and that specificity is exactly what makes it useful.

Economics

This entire workflow runs on Firecrawl and Kiro credits. Scraping a single article costs 1 Firecrawl credit, and with Firecrawl's free tier, you get 1000 for free a month! For six articles, that's 6 Firecrawl credits total.

At the time of writing, Firecrawl's free tier gives you enough to bootstrap this for any reasonable article library.

The cost in terms of Kiro credits may vary depending on how many input articles you use and how complex they are. To scrape, analyze, and write my own writing style guideline, Kiro consumed about 1.30 credits, which amounted to roughly 5 cents of USD at the time of writing. Kiro also comes with a generous free tier of 50 credits a month, so you have plenty of room to experiment.

Why This Matters

Let's talk about the real game-changer here. With your writing style guide available to your AI assistant, every article you write from now on starts from your voice. You don't have to re-explain your style, re-state your preferences, or fix the AI's generic tone in post.

You spend your energy on the ideas, the code, and the architecture. Kiro handles the consistency.

And if your style evolves? Drop a new article into the articles/ folder and regenerate. The guide updates in minutes.

This is the broader Productivity as Code idea in miniature: take something that used to live in your head, encode it as a plain-text artifact, version it, improve it, and let your tools apply it when you need it.

Getting Started

1. Install Kiro
2. Get a free Firecrawl account and configure its MCP tool in Kiro
3. Collect 5-10 URLs of your published articles
4. Ask Kiro to scrape and save them: "Scrape and download these URLs and save them to an articles/ folder"
5. Ask Kiro to analyze them: "Read those articles and create a steering file describing my writing style"
6. Change the file to inclusion: manual if you want to choose when that style applies
7. Use the steering file when drafting your next article

Your next article will already sound more like you.

Follow Along

I've recorded a free video lesson about how to build your own writing style guide as part of my course Productivity as Code. Watch it for free here.

And yes, this is the part where I shamelessly invite you into the course.

If this article made you think, "wait, could I do this for my inbox, my reports, my CRM notes, my weekly updates, my meeting transcripts, and all the other little chores that quietly eat my calendar?" then good. That is exactly the point.

Productivity as Code is about building AI your way: not another random chat window, not another top-down AI mandate, but a practical operating system for your own knowledge work. We use Git, Markdown, Kiro, MCP, and small automations to turn your daily work into something inspectable, reusable, and improvable.

Come for the writing style guide. Stay because boring tasks become strangely fun when you can automate them and still stay in control.

Author

Giuseppe Battista - Senior Startup Solutions Architect at AWS. Leads solutions architecture for Early Stage Startups in UK and Ireland. Hosts "Let's Build a Startup" on twitch.tv/aws.

Follow Giuseppe on LinkedIn