SEO Long-Form Writer: A Skill That Drafts 3,000-Word Articles That Rank

I'll start with the part most "write SEO articles with AI" tutorials skip: the reason your AI drafts don't rank isn't the model. It's that you're asking a language model to do a research-and-judgment job with a one-line prompt, and then you publish the first thing it gives you. The model is fine. Your process is missing four of its five steps.

I built seo-longform-writer to fix exactly that. It's a skill — a reusable, structured instruction set an agent follows — that turns a topic and a target keyword into a 3,000-word article with real structure, internal links, external citations, and valid schema. Not a magic button. A repeatable system that does the boring 80% reliably so I can spend my time on the 20% that actually needs a human: the point of view.

Full disclosure before we go further: almost every article on this site, including the one you're reading, was produced with this exact skill. So I'm not going to hand you theory. I'm going to walk you through the system I run every week, with the prompts, the checklists, and the failure modes I hit so you don't have to.

What this skill actually is (and what it isn't)

Let me set expectations honestly, because hype is the fastest way to lose your trust.

seo-longform-writer is not a content farm. It will not let you publish 50 articles a day, and if you try, you'll get exactly the "AI slop" that Google's helpful content systems are built to demote. What it is: a disciplined pipeline that takes one topic at a time through six passes — research, SERP analysis, outline, drafting, linking and citation, and a self-editing QA pass — and refuses to skip any of them.

The difference between a draft that ranks and one that dies on page 4 is almost never the prose. It's whether the draft:

• Answers the actual search intent behind the keyword
• Covers the subtopics the top results cover (and a few they miss)
• Says something specific and verifiable that a generic article can't
• Is structured so both readers and crawlers can parse it in seconds

The skill encodes all four as steps you can't skip. Here's how each works.

Step 1: Keyword and intent research

Most people pick a keyword by gut. The skill picks one by intent. Before a single word of the article exists, it answers two questions: what exactly is the searcher trying to do, and can I realistically rank for this term.

Search intent falls into four buckets, and the entire shape of your article depends on which one you're targeting:

Intent type	What the searcher wants	Article shape
Informational	To learn or understand	Guide, explainer, how-to
Commercial	To compare before buying	Comparison, "best X", reviews
Transactional	To act/buy now	Product page, tool, signup
Navigational	A specific site or brand	Brand page, docs

If you write a 3,000-word explainer for a transactional keyword, you lose — the searcher wanted a button, not an essay. The skill forces an explicit intent classification first. Here's the prompt block it uses:

Classify the search intent for the keyword: "{{keyword}}".

Return:
1. Primary intent (informational / commercial / transactional / navigational)
2. The job-to-be-done in one sentence ("the searcher is trying to ___")
3. 5-8 closely related long-tail variations and questions
4. The content format that best satisfies this intent
5. A realistic difficulty read: is this a term a focused
   long-form article can rank for, or is it dominated by
   high-authority domains and brand pages?

Be concrete. If the intent is mixed, say so and explain
which sub-intent the article should lead with.

For difficulty, I lean on whatever data you have — Search Console, an SEO tool, or just an honest read of the SERP. The rule of thumb the skill applies: if the first page is all DR-80+ domains and the keyword is broad ("project management"), pick a long-tail variant instead ("project management for solo consultants"). Long-tail terms convert better and rank faster. I'd rather own a 500-search-a-month keyword than rank #40 for a 50,000-search one.

Why intent beats volume every time

I learned this the expensive way. Early on I chased a 12,000-volume keyword, wrote a beautiful guide, and ranked nowhere because the SERP was entirely tool pages — the intent was transactional and I'd written an explainer. The lesson: intent is a filter you apply before you fall in love with volume. The skill makes that filter mandatory.

Step 2: SERP analysis

You don't get to decide what a "complete" article on your topic looks like. Google already decided, and it's showing you the answer on page one. SERP analysis is the step where you read the current top 5-10 results and reverse-engineer the bar you have to clear.

The skill pulls the top results and extracts a structured picture:

Analyze the top 8 ranking pages for "{{keyword}}".

For each result, capture:
- Title and the angle/promise it makes
- Word count (rough)
- The H2/H3 headings (the subtopics they chose to cover)
- The format (listicle, guide, comparison, tool)
- Anything notably good or notably missing

Then synthesize across all of them:
1. The subtopics that appear in MOST results
   (these are table stakes — I must cover them)
2. The questions in "People Also Ask" and related searches
3. A content gap: what is under-covered or missing entirely
   that I can own?
4. The realistic depth bar (word count + comprehensiveness)

Two outputs matter most here. Table stakes — the subtopics nearly everyone covers — are non-negotiable; omit them and you signal incompleteness. The content gap is where you win. If eight articles all explain what prompt chaining is but none give a copy-paste template, your template is your differentiation. I cover the broader research workflow in my guide on writing SEO articles with AI, but the SERP gap is the single highest-leverage thing you'll find in that process.

The top-ranking page is your spec, not your ceiling. Match its coverage, then beat it on one specific dimension you can genuinely own. "A bit longer" is not a dimension. "Includes the actual config file" is.

Step 3: The outline, built around intent and headings

Now we structure. A good outline does three jobs at once: it satisfies the intent, it covers the table-stakes subtopics, and it sequences everything the way a reader's questions naturally unfold.

The skill builds the outline as a heading tree, because your H2/H3 structure is your on-page SEO skeleton. Headings tell crawlers what the page is about and let readers scan. They also map cleanly to featured snippets and the "People Also Ask" box.

Here's the structure the skill targets for a 3,000-word informational article:

• H1: one, contains the primary keyword, reads like a promise
• Intro: hook + what the reader will get, no throat-clearing
• 7-10 H2 sections: each a distinct subtopic from SERP analysis
• H3s under H2s: for sub-points, examples, edge cases
• Lists and a table: wherever they compress information
• FAQ section: built from "People Also Ask" questions
• Closing + resources: next steps and links

The outline prompt:

Build a heading outline for a {{word_count}}-word article
targeting "{{keyword}}" with {{intent}} intent.

Requirements:
- One H1 that includes the keyword and reads as a promise
- 7-10 H2 sections that together cover every table-stakes
  subtopic from the SERP analysis, plus the content gap
- H3 subsections where a topic needs breakdown
- Mark where a list, table, code block, or example belongs
- An FAQ section seeded with the real "People Also Ask"
  questions
- Order sections by the reader's natural question sequence,
  not by what's easiest to write

For each H2, write one sentence describing what it must
accomplish and the specific example or detail it will use
to avoid being generic.

That last line — the specific example it will use — is the secret. If you plan the specificity at the outline stage, the draft can't drift into vague filler. Every section has a concrete thing it's obligated to deliver.

Map keywords to sections, lightly

I assign the primary keyword to the H1, intro, and one H2, then sprinkle the long-tail variations naturally across headings and body. No density targets, no stuffing. Modern search engines understand topics, not keyword counts. Write for the human; the entities take care of themselves. If you want the deeper mechanics of how I phrase prompts to keep this natural, my complete prompt engineering guide goes section by section.

Step 4: Drafting in passes

Here's where most AI workflows break: they ask for the whole article in one shot. You get 3,000 words of smooth, confident, utterly generic text. The fix is to draft in passes, section by section, feeding the model the outline and the specific obligation for each part.

I run three drafting passes:

Pass 1 — Section drafts. Generate each H2 section individually, giving the model the section's goal and its mandatory specific detail. One section per prompt keeps the model focused and lets you catch drift early.

Draft the section "{{H2 heading}}" for an article on
"{{keyword}}".

Context:
- The article's overall angle: {{one-line thesis}}
- This section must accomplish: {{goal from outline}}
- It must include this specific example/detail: {{detail}}
- Preceding section ended on: {{last point}} (so transition
  cleanly)

Constraints:
- 300-450 words
- First person, confident, practical, no hype
- Include a concrete example, number, or named tool — not
  a generic statement
- One short list OR one code/example block if it earns its
  place
- Do not restate the section title as the first sentence

Pass 2 — Seams. Read the assembled sections together and fix transitions, kill repetition, and make sure the thesis carries through. Sections written in isolation always have rough seams; this pass smooths them.

Pass 3 — Voice and specificity injection. This is where the article stops sounding like a machine. I go section by section and force one real thing into each: a number, a named tool, a mistake I made, a counterintuitive opinion. Generic-to-specific is the single biggest quality lever you have.

Compare:

• Generic: "Internal linking is important for SEO."
• Specific: "When I added five contextual internal links to an orphaned post, it went from zero impressions to ranking top-10 for its target term in about three weeks — links pass relevance and crawl priority, not just authority."

Same claim. One is forgettable; one is evidence. The skill's drafting pass rejects the first kind on sight.

Step 5: Internal links and external citations

A long-form article is a hub. It should link out to authoritative sources (which builds trust and gives crawlers context) and link internally to your related content (which spreads authority and keeps readers on your site).

Internal links are the higher-leverage of the two, and they're criminally underused. Every article on a well-structured site should connect to its neighbors. The skill's rule: 3-8 contextual internal links per long-form piece, placed where they genuinely help the reader go deeper, with descriptive anchor text. Never "click here." The anchor should tell you where you're going.

For this skill specifically, the natural internal neighbors are pieces like my AI tool curator skill for finding what to write about, the productized AI service skill for turning content into a business, and the context engineering skill for feeding the model the right inputs. Notice how each link is justified by the sentence around it — that's the standard.

External citations back up your claims. Link to primary sources: official docs, original research, the standards themselves. When I say something about how Google treats helpful content, I link to Google Search Central, not to some other blog's summary of it. Primary sources signal that you did the work.

The linking prompt:

Review this draft and add links.

Internal links (3-8 total):
- Identify phrases where a reader would benefit from a
  related article on the same site
- Use descriptive anchor text (never "click here")
- Available internal targets: {{list of slugs + topics}}

External links (2-5 total):
- Link claims that need backing to PRIMARY sources
  (official docs, original research, standards)
- No links to competitor content I'm trying to outrank
- Open authoritative references, not blog aggregations

Output the edited draft with links in Markdown, plus a
short list explaining why each link was added.

Step 6: On-page SEO — the technical layer

The article is written. Now we make it legible to search engines. This is mechanical and easy to get right with a checklist, which is exactly why so many people skip it and leave ranking on the table.

Here's the full on-page checklist the skill applies:

• Title tag (50-60 chars): includes the primary keyword near the front, written to earn the click. This is not always identical to the H1.
• Meta description (150-160 chars): a compelling summary with the keyword. It doesn't directly affect ranking, but it drives click-through, which does.
• URL slug: short, hyphenated, keyword-bearing, no stop words. /seo-longform-writer, not /the-best-way-to-write-seo-articles-in-2026.
• One H1: contains the keyword, matches the page promise.
• Logical H2/H3 hierarchy: no skipped levels, no decorative headings.
• Image alt text: descriptive, natural, keyword where it fits honestly. Alt text is for accessibility first; SEO benefit is a bonus.
• FAQ section: answers the real "People Also Ask" questions in a clear Q/A format.
• Schema / JSON-LD: structured data so search engines understand the page type.

Schema and JSON-LD

Structured data is the part people find intimidating and shouldn't. For an article with an FAQ, you want two schema types: Article and FAQPage. Here's the FAQ schema the skill generates from the article's FAQ section:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Can AI write SEO articles that actually rank?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes, when the AI follows a research-first
        process: intent analysis, SERP analysis, a structured
        outline, drafting in passes, and a human editing pass
        for specificity. The model is not the bottleneck; the
        process is."
      }
    },
    {
      "@type": "Question",
      "name": "How long should an SEO article be?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Long enough to fully cover the intent and
        match the depth of the top-ranking pages. For
        competitive informational keywords that is often
        2,000-3,000+ words, but length follows completeness,
        not the other way around."
      }
    }
  ]
}

This goes in a <script type="application/ld+json"> tag in the page head. Valid schema can earn you rich results — the expandable FAQ accordions and other enhancements that take up more SERP real estate. Always validate it with Google's Rich Results Test before publishing; one malformed bracket and the whole block is ignored.

E-E-A-T and the war against AI slop

Google's quality guidelines lean hard on E-E-A-T: Experience, Expertise, Authoritativeness, Trustworthiness. The newest and most important letter is the first E — Experience. Google wants content from someone who has actually done the thing, not someone who paraphrased ten other articles. This is precisely the dimension AI struggles with by default, which is also your opportunity.

"AI slop" is the term for content that's grammatically perfect and informationally empty. It's confident, fluent, and says nothing a hundred other pages don't. Google's helpful content systems are explicitly tuned to demote it. So the skill's most important job is to resist its own nature and force in the things that make content human.

Here's the anti-slop checklist the skill runs on every draft:

• Specificity over generality: numbers, names, dates, versions. "Increased traffic" → "went from 200 to 1,400 clicks/month over a quarter."
• Real examples: a thing that actually happened, a screenshot-able result, a config that runs.
• A point of view: an opinion or a recommendation, including what not to do. Generic content is neutral; useful content takes a side.
• Experience markers: "when I tried this," "the mistake I made," "what surprised me."
• No filler phrases: kill "in today's fast-paced digital world," "it's important to note," "the ever-evolving landscape." These are slop tells.
• Honest limits: say what the approach doesn't do. Trust is built by admitting boundaries.

The point of view is the thing AI can't fake and competitors can't copy. My take that "the model is never the bottleneck, your process is" is contestable — and that's what makes it worth reading. Bland agreement ranks nowhere. If you want the broader philosophy on building content that earns trust, the make money with AI guide gets into how this compounds into an actual asset.

Step 7: The self-editing QA pass

The final pass is where good drafts become publishable ones. The skill runs the article through a structured QA review against every requirement, and it's adversarial on purpose — it's looking for reasons to reject, not approve.

Review this article as a harsh editor. For each item, mark
PASS or FAIL with a one-line reason. Then list required fixes.

Intent & coverage:
- Does it satisfy the classified search intent?
- Does it cover every table-stakes subtopic from the SERP?
- Does it deliver on the content gap / differentiation?

Structure:
- One H1 with the keyword? 7-10 logical H2s? Clean hierarchy?
- At least one table and several lists where they help?
- FAQ section answering real PAA questions?

Quality (anti-slop):
- Every section has a specific example, number, or named tool?
- Clear point of view present?
- Zero filler phrases? Flag each one you find.
- Reads like a human who did the work wrote it?

On-page SEO:
- Title tag 50-60 chars, keyword-forward?
- Meta description 150-160 chars, compelling?
- Slug short and keyword-bearing?
- Internal links 3-8, descriptive anchors?
- External links to primary sources?
- Valid Article + FAQPage JSON-LD?

Output: a checklist of PASS/FAIL plus a prioritized fix list.

I take the fix list, apply it, and re-run until everything passes. Two passes is typical. The discipline of an explicit checklist is what makes the output consistent — I'm not relying on the model "feeling done," I'm verifying against a spec. This is the same spec-driven mindset I use for code, which I unpack in the spec-driven development guide.

A note on factual QA

The skill never trusts the model's confidence on facts. Any statistic, quote, or claim about how a search engine behaves gets verified against a primary source or removed. A single fabricated stat tanks your trustworthiness more than ten missing ones. When in doubt, cut it or cite it.

How I actually run this, end to end

Here's the realistic cadence for one article, start to publish:

1. Pick a keyword and run intent classification (5 min)
2. SERP analysis to find table stakes and the gap (10 min)
3. Generate and hand-tune the outline (10 min)
4. Draft section by section, three passes (30-40 min)
5. Add internal links and external citations (10 min)
6. On-page SEO: title, meta, slug, alt, schema (10 min)
7. Self-editing QA pass, apply fixes, re-run (15 min)

That's roughly 90 minutes of focused work for a 3,000-word article that's genuinely good — not a button you press, but a fraction of the time a manual draft of equal quality would take. The skill removes the blank-page paralysis and the structural guesswork. The human time goes entirely into specificity and point of view, which is exactly where it should go.

And yes — this page went through that same pipeline. The intro hook, the SERP-derived sections, the table, the FAQ, the schema, the internal links to my other skills: all of it is the system describing itself. If it reads like a human who's done this a few hundred times wrote it, that's the anti-slop pass doing its job.

Where this fits in a content system

One article is a tactic. A content engine is the strategy. seo-longform-writer is the drafting core, but it works best surrounded by:

• A topic pipeline (what to write next) — that's what the AI tool curator skill feeds me
• A distribution and monetization layer — covered by the productized AI service skill
• A context layer so the model has your real data and voice — the context engineering skill

Together they form a loop: find the topic, draft it well, publish, measure in Search Console, and feed what's working back into the topic pipeline. The drafting skill is one gear, but it's the gear that turns research into something that ranks.

Resources & links

Internal:

• Write SEO Articles With AI: The Complete Workflow — the human-side companion to this skill
• Prompt Engineering: The Complete Guide for 2026 — how to phrase the prompts in this pipeline
• Spec-Driven Development for AI Agents — the checklist mindset applied to building
• Make Money With AI in 2026 — turning a content engine into an asset
• AI Tool Curator skill — the topic-discovery feeder
• Productized AI Service skill — packaging content into a business
• Context Engineering skill — feeding the model your real data and voice
• AI Content Creation track — the full learning path this skill belongs to

External:

• Google Search Central — the primary source for everything ranking-related
• Google Search Essentials — the baseline rules a page must meet
• Creating helpful, reliable, people-first content — Google's own E-E-A-T and anti-slop guidance
• Rich Results Test — validate your JSON-LD before publishing
• Schema.org Article and FAQPage — the structured data vocabularies