DEV Community: Jayanth

I Gave Mistral Remote Agents a Real Coding Task, Closed My Laptop, and Came Back to a Finished App

Jayanth — Fri, 08 May 2026 11:30:24 +0000

The task I used to test this

I did not want to test something new.
No hello-world prompt.
No "generate a function" demo.
I gave it a task I would normally spend 30–45 minutes on myself:

`"Build a complete sales dashboard application and prepare it for deployment."`

This is a task that typically requires:

`Prompt → Review output → Fix errors → Re-prompt → Adjust → Fix again → Finalise`

You stay in the loop the entire time. That is the normal pattern with Claude, GPT or any standard AI coding assistant. The model responds step-by-step. You guide every step.
I hit enter.
Watched it start.
Then I closed my laptop and did not check back.

What I expected vs what I found

When I came back, I expected one of three outcomes:


``
> 1. Half-finished output with obvious gaps
> 2. Broken code requiring significant fixes
> 3. A "draft" response asking clarifying questions`

What I found instead:

plaintext✓ Application structure fully built
✓ UI components organised and functional
✓ Core logic implemented
✓ Deployment-ready configuration included

I had not guided it through a single step. I had not fixed anything midway. I had not even stayed in the session.
That is the distinction that matters. Not better output — different category of behaviour.

What Mistral Remote Agents actually does (architecture breakdown)

Remote execution

Standard AI coding assistants are tied to your active session. When you close the tab, execution stops. The model waits for your next message.
Mistral Remote Agents changes this model:

Standard assistant:
You (active) → Prompt → Model responds → You review → Re-prompt → Repeat

Remote agent:
You define task → Agent executes in cloud → You return to results`

The task moves to cloud execution. It continues independently. Your presence is not required for execution to complete.

Work mode — tasks not responses

Inside Mistral's interface, Work Mode treats your input as a workflow objective rather than a prompt requiring a single response.

`Traditional model:       "Here is your answer"
Work mode:               "Here is the completed outcome"`

The model plans internal steps, executes them in sequence, and delivers a finished state rather than a sequence of responses you have to assemble.
Tool integration

The system connects to:

`GitHub        — code repository management
Project tools — task and workflow tracking
Internal APIs — custom integrations`

This means the agent is not just generating text that looks like code. It can structure files, prepare deployment configurations, and organise output for real-world use rather than copy-paste from a chat window.

Single model for reasoning + coding + execution planning
There is no switching between tools or models for different parts of the task. Reasoning, code generation, and execution planning happen in one flow. No fragmentation, no context loss between tool handoffs.

The workflow model shift

This is the part most coverage gets wrong by treating it as a feature comparison.
Before — how we currently use AI for coding:

`# The standard loop
while task_not_complete:
    user_prompt = input("What to do next?")
    response = model.respond(user_prompt)
    user.review(response)
    user.fix_errors(response)
    user.decide_next_step()`

The user is the execution layer. The model is the generation layer. You manage every transition.
After — what agent-based execution enables:

`# The agent model
task = define_objective("Build sales dashboard, deploy-ready")
agent.execute(task)
# ... you do other work ...
result = agent.get_result()
user.review(result)
user.adjust_if_needed(result)`

The agent manages the transitions. You define the start and review the end. Everything in between is the agent's responsibility.

This is not a performance improvement. It is a workflow architecture change.

What I changed after the first test

After the initial result, I ran more tasks and noticed what determines output quality.

Task definition clarity matters more than task complexity
Vague objectives produce vague results regardless of model capability. The agent cannot fill gaps in your intent the way you can through iterative prompting.

`Weak:   "Build something useful for tracking sales"

Strong: "Build a sales dashboard with:
         - Monthly revenue chart (bar chart)
         - Top 5 products by volume (table)
         - Conversion rate by source (pie chart)
         - CSV export button
         - Deployment configuration for Vercel"`

The second input removes ambiguity the agent would otherwise resolve with assumptions.
Structured inputs replace iterative correction
In the standard model, vague prompts are cheap because you correct through follow-up messages. In the agent model, vague prompts cost you more because the agent completes a full execution cycle before you can course-correct.

Front-load the specificity. The investment in a detailed task definition pays back in output that needs minimal revision.
Reviewing replaces prompting
The interaction pattern changes:

`Standard AI:    Prompt → Review → Prompt → Review → Prompt
Remote agent:   Define → [agent executes] → Review → Adjust → Finalise`

The skill set that produces good results shifts from "prompt engineering" to "task specification" and "output evaluation."

Honest limitations

This is not a replacement for every coding workflow.
Tasks that require ongoing creative decision-making — where the direction changes based on intermediate results — still benefit from the interactive model. The agent cannot detect that you have changed your mind mid-execution.

Output quality on complex tasks is high as a starting point, not necessarily as a final product. Some outputs need tweaking. The meaningful difference is where you start: from zero versus from 80% complete.

Integration setup with GitHub and project tools requires configuration time upfront. The first session involves more overhead than a standard AI chat. The payoff is subsequent sessions where the context and tooling are already in place.

The practical implication

The distinction between "AI assistant" and "AI agent" is not semantic. It maps to a real difference in how your time is allocated:

Assistant model: your time → mostly spent in the prompt-fix loop
Agent model: your time → task definition + final review

For developers and builders running multiple projects simultaneously, the compounding effect is significant. Tasks that required active attention can run in the background. Your focus time goes to the parts that genuinely require it.

This is early. The integrations are not seamless and task failures do happen. But the architecture is categorically different from what most developers are using daily, and the gap between the two models is going to widen.

Full breakdown in the original Medium article.

Have you tested agent-based coding tools on real production tasks? Drop what held up and what broke in the comments.

Claude + Canva Integration — I Built an Instagram Carousel in 5 Minutes (Full Workflow)

Jayanth — Thu, 07 May 2026 15:41:42 +0000

What this actually is (and what people get wrong)

Most people see "Claude Canva integration" and assume it is AI generating images or suggesting layouts. That is not what it does.
What it does: Claude structures an entire design — slide layouts, content, hierarchy — and exports it directly into Canva as a fully editable project. You do not receive a static image. You receive a Canva file you can open and modify exactly like any template you would start from scratch.

The practical difference: instead of opening Canva, choosing a template, adjusting the layout, and writing the content — you describe what you want, Claude builds the 80% version, and you spend your time on the 20% that requires your specific branding and voice.
Here is the exact workflow that replaced my manual design process.

Prerequisites

`Claude account (any paid plan)
Canva account (free tier works)
The Canva connector enabled inside Claude`

Step 1 — Enable the Canva connector

This step is non-negotiable. Without it, Claude cannot export anything into Canva.
Inside Claude:

`Dashboard → Customize → Skills → Connectors → Find Canva → Connect account`

OAuth flow — takes about 60 seconds. Once connected, the connector persists across sessions. You only do this once.

Step 2 — Access Claude Design mode

After connecting Canva, return to your Claude dashboard. You will see a new option: Claude Design.
This is separate from the standard chat interface. You are not prompting for text. You are prompting for a designed output. The distinction matters for how you write your prompt.

Step 3 — Create a new design project and set your type

Inside Claude Design, create a new project. Define the design type clearly.
Examples:

`Instagram Carousel
LinkedIn Post
Presentation Deck
Email Header
Story Slide`

This tells Claude the dimensions, layout constraints, and output format before anything is generated.

Step 4 — Select High Fidelity mode

Two options are available: Low Fidelity and High Fidelity.

`Low Fidelity  = rough structural draft, loose layout
High Fidelity = clean usable design, structured output`

Always use High Fidelity for anything that will be exported. Low Fidelity is useful for quickly checking whether a concept layout works before committing to a full generation.

Step 5 — Upload visual references (optional but high-impact)

Claude accepts uploaded screenshots, mood boards, or existing designs as visual references. This is where most people underestimate the system.
Instead of describing your desired style in text — which is inherently imprecise — show it:

`Upload 2–3 carousel examples whose style matches your target
Claude reads the visual patterns: spacing, typography weight, color approach
Output accuracy improves significantly compared to text-only prompts
`

If you have a brand style guide or competitor carousel that represents the aesthetic you want, upload it here. The generated output will reflect those visual patterns rather than Claude's defaults.

Step 6 — Write a specific prompt

The quality of the generated design scales directly with the specificity of the prompt. This is where most people leave performance on the table.
Weak prompt:

`"Create a carousel about AI tools"`

Strong prompt:

`"Create a 5-slide Instagram carousel with:
- Bold headline on each slide (max 6 words)
- Supporting text under each headline (max 20 words)
- Minimal white background design
- Topic: 5 AI tools that save 10 hours per week
- Slide 1: Hook/problem statement
- Slides 2–5: One tool per slide with one key benefit
- Final slide: CTA to follow for more"`

The second prompt tells Claude the slide count, content structure, visual style, topic, and the purpose of each slide. Claude does not need to make assumptions when the brief is this specific. Fewer assumptions mean fewer iterations.

Step 7 — Let Claude ask clarifying questions

After submitting your prompt, Claude does not immediately generate. It asks questions to resolve remaining ambiguity: content depth per slide, colour preferences, font style direction, any specific wording you want preserved.
Most people find this step slightly frustrating and try to skip past it. This is a mistake. The questions surface assumptions that would otherwise produce a design you need to revise significantly. Answering them thoroughly gets you closer to a first draft that requires minimal editing.

Step 8 — Review the generated output

Generation typically takes 2–4 minutes depending on slide count and complexity.
The output preview shows:

`Layout structure per slide
Content placement and hierarchy
Typography choices
Spacing and visual balance`

At this stage, you are not looking for perfection. You are evaluating whether the structure is correct and whether the content is in the right places. Colour, fonts, and exact wording are all editable in Canva — do not try to perfect those through additional Claude prompts.

Step 9 — Export to Canva

When you are satisfied with the structure, click Export to Canva.
The design transfers to your Canva account and opens as a new project. Every element — text boxes, layout blocks, colour fills — is independently editable. This is not a flattened image. It is a layered Canva file.

Step 10 — Finalise in Canva

Standard Canva workflow from here:

`Replace placeholder fonts with your brand fonts
Apply your brand colour palette
Replace any generic text with your specific copy
Add your logo or profile photo where relevant
Adjust any spacing that looks off on mobile preview
Download or publish directly`

Total time from prompt to export for a 5-slide carousel: approximately 8–12 minutes including the clarifying questions. Total Canva editing time for brand alignment: approximately 5–10 minutes depending on how many brand elements you are adding.

What the workflow shift actually means

The old process for a carousel:

`Idea → Open Canva → Choose template → Not quite right → Choose another → 
Adjust layout → Write content → Realise layout doesn't fit content → 
Adjust again → Add branding → Publish`

The new process:

`Idea → Describe it → Claude generates structure → Export → Add branding → Publish`

The removal of the "starting from scratch" step is the meaningful change. Not because Claude's output is perfect, but because an 80% starting point with correct structure eliminates the most time-consuming part of the process — the blank canvas decision loop.

Limitations worth knowing

Claude's colour defaults are generic. Always plan to replace the colour palette in Canva with your brand colours — do not try to specify exact hex values in the prompt, the results are inconsistent.
Font selection is limited to what Claude defaults to. Canva's font library covers the final step.

For highly complex layouts — asymmetric grids, layered image compositions — the output sometimes needs significant restructuring. Claude handles standard grid-based carousel layouts well. Experimental layouts less so.
For standard content formats (carousels, listicle slides, educational posts), the workflow saves meaningful time. For highly custom branded content that diverges significantly from standard layouts, expect to spend more time in Canva editing.

Full workflow breakdown with screenshots in the original medium post.

Using this for a niche where carousels perform differently to average? Drop your use case in the comments — interested in how the workflow holds up across different content types.

I Kept Hitting Claude Token Limits Until I Tracked What Was Actually Burning Them

Jayanth — Wed, 06 May 2026 13:55:06 +0000

The pattern that made no sense

Some days I barely used Claude and hit the limit early. Other days I pushed it hard and lasted much longer.
If the platform was the problem, the behaviour should be consistent. It was not — which meant the variable was me, not the system.
I started tracking everything: how I was prompting, how long my sessions ran, what types of tasks I was running, what differed between good days and bad days. The pattern that emerged was clear once I could see it.
I was not running out of messages. I was burning tokens — silently, in ways that felt completely normal.

Why token limits feel invisible

Most developers think of API cost in terms of individual requests. The problem with Claude (and any context-window model) is that cost is not per-request in any intuitive sense. It is per-token-processed, and that includes:

`Every message you send now
+
Your entire conversation history
+
Any files currently in context
+
Any active tools or integrations
+
All previous responses in the thread`

So every single message you send causes Claude to reprocess the entire accumulated weight of the conversation. A short chat is cheap. A long chat becomes exponentially expensive — not linearly.
This is why the limit can feel random. It is not random at all. It is the silent compounding of context weight across every turn.

The 10 changes that fixed it

Edit the original prompt instead of stacking follow-ups

This was the highest-impact change I made.
What I was doing:

`Message 1: "Write me an intro for this post"
Message 2: "Make it shorter"
Message 3: "Add more energy to the opening line"
Message 4: "Actually, change the angle entirely"`

Each of those follow-ups looks like a small correction. What it actually is: a full context reload multiplied four times.
What I changed to:
Edit the original prompt directly instead of appending corrections. Claude processes one refined version with one context load instead of four cumulative loads.
Immediate result: sharper outputs, fewer iterations, lower token burn.

2. Reset sessions before context gets heavy

At message 5, Claude might process a few hundred tokens of history. At message 25, it could be processing tens of thousands — for every single new message, including simple questions.
The pattern I use now:

`After every 15–20 messages:
1. Ask Claude: "Summarise everything we have covered so far in this session."
2. Copy the summary.
3. Open a new chat.
4. Paste the summary as the opening context.`

You keep continuity. You eliminate history weight. Same outcome at a fraction of the token cost.

3. Combine multi-step tasks into single execution prompts

Before:

`Prompt 1: "Summarise this document"
Prompt 2: "Now extract the key points"
Prompt 3: "Rewrite the intro in under 100 words"`

Three context loads. Three rounds of history reprocessing.
After:

`"Summarise this document, extract the key points as bullets, 
and rewrite the intro in under 100 words. Return all three 
in separate labelled sections."`

One context load. One processing cycle. Better output because Claude sees the full scope of what you need before it starts.

4. Stop re-uploading the same files

Every time you upload a file, Claude reprocesses it from scratch — even if it is identical to one you uploaded two messages ago. This is a hidden cost that does not feel like a cost because the UX treats uploads casually.
Fix: Use Projects to store reference files once. Files in a Project are cached in context rather than reprocessed per upload. For workflows that reference the same documentation, codebase, or data repeatedly, this alone produces significant savings.

5. Store persistent instructions once

If you start every session with:

`"I am a developer building automation workflows. 
Write in a concise technical tone. 
Use code blocks for all examples. 
Avoid unnecessary explanation."`

You are burning those tokens every single session. Stored in a Project's system instructions or a reusable prompt template, they load once — and you stop paying for them repeatedly.

6. Disable tools you are not actively using

Active tools — web search, integrations, connected services — add processing overhead even when they are not being called in a given turn. The model still has to account for their presence in every response.
Default posture: everything off. Enable specific tools only for sessions where they are required. Disable them when done. The per-turn cost reduction is small but it compounds across long sessions.

7. Match model to task complexity

Task type	Model tier
Simple Q&A, lookup	Lightest available
Writing, summarisation	Mid-tier
Complex reasoning	Heavy model
Code generation	Depends on complexity

Using Claude's most powerful model for every task is the equivalent of running a GPU render for a text file. The lighter models handle most everyday tasks at lower token cost per output token. Reserve heavy models for tasks that genuinely need them.

8. Write specific, scoped prompts

Vague prompts produce long outputs. Long outputs consume output tokens. Output tokens cost more per unit than input tokens.
Before:

`"What do you think about this approach?"`

After:

`"List the 3 main risks with this approach. 
Each risk in one sentence. No intro or conclusion."`

The second prompt produces a shorter, more useful response — and costs less to generate. Specificity is free. Vagueness is expensive.

9. Timing matters more than expected

Heavy usage periods produce tighter limits and slower responses regardless of your plan tier. If you are running intensive sessions — large context windows, complex reasoning tasks, multi-file workflows — scheduling them outside peak hours produces longer effective sessions and more consistent availability.

10. Track what you are actually burning

None of these changes matter without visibility. Start logging:

`# Minimal usage tracking
session_start_tokens = get_token_count(initial_context)
after_message_tokens = get_token_count(full_context)
delta = after_message_tokens - session_start_tokens
print(f"This message cost: {delta} tokens")
print(f"Session total: {after_message_tokens} tokens")`

When you can see the delta on each turn, the expensive patterns become obvious within a few sessions. The invisible becomes trackable.

The four patterns that account for most waste

After implementing all of the above, four root causes produce the majority of unnecessary token consumption:
Long unmanaged conversations — context weight compounds exponentially. Reset and summarise before turn 20.
Repeated file uploads — every upload is a full reprocess. Use Projects for persistent files.

Active unused tools — overhead exists whether you call them or not. Disable by default.
Heavy models on simple tasks — every output token from the heaviest model costs more than the same token from a lighter one. Match the tool to the job.
Fix these four and the limit stops feeling like a restriction. It starts feeling like something you can comfortably stay inside with normal usage.

The mental model that actually changes behaviour

I used to frame it as: Claude is limiting me.
The accurate frame is: my workflow was consuming more than it needed to.
Token limits are signals, not ceilings. They show you exactly how efficiently you are using the system. When you design prompts the way you would design efficient queries — send only what is needed, scope the output, reset before state compounds — the limit stops being a problem you bump into and starts being something you never think about.

Full breakdown of these patterns with usage examples in the original Medium article.

What is the pattern that hits you hardest? Long sessions, re-uploads, or something else entirely — drop it in the comments.

My Claude API Bill Jumped 47% and I Didn't Change a Single Prompt — Here's Why

Jayanth — Mon, 04 May 2026 06:09:32 +0000

The problem nobody warned me about

Same prompts. Same workflows. Same model. Higher bill — every single week.
I checked my logs expecting to find a spike in usage. Instead I found something stranger: the same prompt returning different token counts on different runs. Some runs were 30–47% higher than identical runs a few weeks earlier.

No input change. No structural change. Just more tokens — and a cost bill I could not explain.
After going through Reddit threads, developer forums, and an OpenRouter analysis of over 1M+ real API requests, here is what is actually happening and the six changes that brought my token usage back under control.

What changed under the hood

Three things shifted simultaneously, and most cost-increase explanations only mention one of them.

1. The tokenizer itself changed

Claude's tokenizer now splits text differently. Same input produces more token segments. The expected increase from this alone is roughly 1.0x–1.35x. But real-world data from high-volume API users shows 1.4x–1.47x increases — and sometimes higher on specific content types.
Code blocks, markdown formatting, and JSON structures are hit disproportionately hard because of how subword tokenisation handles special characters and whitespace patterns in technical content. If you are building coding assistants, agent workflows, or automation pipelines, your content type is in the high-impact zone.

2. Newer model versions reason deeper by default

More recent Claude versions spend more internal token budget on reasoning before generating output. This is the "thinking more" behaviour — better response quality, more tokens burned per request. If you upgraded model versions without adjusting your prompting approach, you absorbed a reasoning cost increase on top of the tokenizer change.

3. Conversations compound exponentially

Every message in a multi-turn conversation appends to the context window. With each individual message now slightly larger than before (due to tokenizer changes), long sessions accumulate token weight faster than the same sessions would have previously. A ten-turn conversation that used to cost X tokens now costs 1.4X or more — and that multiplier applies to every turn, not just the last one.

The real-world impact on different use cases

Use case                  | Token impact | Why
--------------------------|--------------|------------------------------------
Coding assistant          | Very high    | Code blocks + formatting = heavy tokenisation
Long agent workflows      | Very high    | Multi-turn accumulation compounds
Single short prompts      | Low          | Minimal compounding, tokenizer delta only
Automation with full logs | Very high    | Raw log data is extremely token-inefficient
Repeat identical prompts  | Medium-low   | Caching mitigates tokenizer delta

If your workflow sends full files, complete conversation histories, or raw log output to the API — you are in the highest impact category.

The six changes that actually reduced my costs
1. Stop sending unnecessary context
Before:

`# Sending everything
messages = [
    {"role": "user", "content": full_file_contents + full_history + current_question}
]`

After:

`# Send only what the model needs for this specific task
relevant_context = extract_relevant_section(file_contents, current_question)
messages = [
    {"role": "user", "content": relevant_context + current_question}
]
`

Result for my workflow: 40% token reduction on input alone. The model does not need your entire codebase to answer a question about one function.

2. Break large prompts into focused smaller ones

Before:

`One prompt that asks: analyse this code, suggest improvements, 
rewrite the function, add error handling, and write unit tests.`

After:

`Prompt 1: Analyse this function for issues (code only, no file context)
Prompt 2: Rewrite with suggested fixes applied (function only)
Prompt 3: Add error handling to this specific function
Prompt 4: Write unit tests for this function signature`

Each smaller prompt is cheaper than one large prompt, and the outputs are easier to validate and iterate on.

3. Match reasoning effort to task complexity

Claude's newer versions apply heavier reasoning by default. For tasks that do not require deep reasoning — format conversion, simple extraction, classification — you can explicitly instruct the model to keep responses concise:

`system_prompt = """
Answer directly and concisely. 
Do not show your reasoning unless asked.
Do not pad the response with caveats or summaries.
"""`

Saved approximately 15–20% on output tokens for my classification tasks where verbose responses were not needed.

4. Reset sessions instead of accumulating context

Before: One long continuous session per agent workflow.
After: Fresh session when the conversation exceeds a threshold.

`MAX_CONTEXT_TURNS = 8

if len(conversation_history) > MAX_CONTEXT_TURNS:
    # Summarise previous turns into a single context block
    summary = summarise_history(conversation_history)
    conversation_history = [{"role": "user", "content": f"Context: {summary}"}]`

This prevents the exponential compounding problem. Each accumulated turn is now slightly heavier — capping accumulation and replacing with a summary keeps costs predictable.

5. Clean and compress inputs before sending

Before: Raw log output, unformatted JSON, full HTML responses pasted directly.
After:

`def compress_for_api(text):
    # Remove blank lines
    text = '\n'.join(line for line in text.splitlines() if line.strip())
    # Remove HTML if only text is needed
    text = re.sub(r'<[^>]+>', '', text)
    # Truncate repeated whitespace
    text = re.sub(r' +', ' ', text)
    return text.strip()`

Cleaning inputs before sending reduced my token count by 20–30% on workflows that process scraped web content.

6. Optimise stable prompts for prompt caching

Claude's prompt caching charges a lower rate for repeated identical prompt prefixes. Structure your system prompts so the stable portion comes first and the dynamic content comes at the end:

`# Structure that caches well:
system = """[Your long, stable system prompt here — this gets cached]"""

user = f"""
Context for this specific request: {dynamic_context}
Task: {specific_task}
"""`

Caching only applies to the prefix that stays identical between calls. If your system prompt varies per request, caching does not help — standardise it.

The mental model shift that matters

The problem is not that Claude got worse or more expensive for no reason. The tokenizer change reflects better text processing. The deeper reasoning produces better outputs.

What changed is the default efficiency assumption. Prompts and workflows designed for the old tokenizer behaviour were implicitly relying on cheaper processing. That assumption no longer holds.

The fix is not "use less AI." The fix is designing your prompts the way you would design efficient database queries — send only what is needed, structure it cleanly, cache what repeats, and reset state before it compounds.

Full breakdown with context on the OpenRouter analysis at my Medium article.

Have you hit this in your own workflows? Drop your use case and the token multiplier you observed in the comments — trying to build a picture of which workflows are hit hardest.

I Built an n8n Workflow That Generates “Top 10” Videos Automatically (System Design + Lessons)

Jayanth — Wed, 29 Apr 2026 13:45:23 +0000

Why I built this

Creating content manually doesn’t scale.

Even a simple “Top 10” video takes:

research
scripting
editing
uploading

Repeat that daily → it becomes a bottleneck.

So instead of optimizing the process…

I removed myself from it.

What this system does

This workflow automatically:

generates topics
writes structured scripts
creates voiceovers
generates visuals
assembles final videos

Runs on a schedule.

No manual input.

Architecture

`Scheduler (cron)
↓
Topic Generator (AI)
↓
Script Generator (Top 10 format)
↓
Voice Generation (TTS)
↓
Visual Generation
↓
Video Assembly
↓
Upload / Storage`

This type of pipeline is possible because :contentReference[oaicite:0]{index=0} connects APIs and services into deterministic workflows that execute predefined steps reliably. :contentReference[oaicite:1]{index=1}

Step 1 — Trigger (Scheduler)

Cron node runs daily
Starts entire pipeline automatically

Step 2 — Topic Generation

AI generates topics like:

“Top 10 AI tools”
“Top 10 productivity apps”

Insight:

Topic quality = performance

Bad topic → system still runs → bad output at scale

Step 3 — Script Generation

Strict structure:

Hook
Intro
Ranked list (#10 → #1)
Outro

Example:


txt
Top 10 AI tools you need in 2026

#10 ...
#9 ...
...
Why this matters

Structured formats are predictable → perfect for automation


**Step 4 — Voice Generation**
Text → speech (TTS / cloned voice)
Short sentences only
Common mistake

Long paragraphs → unnatural audio → low retention


**Step 5 — Visual Generation**

For each list item:

generate image / clip
map to script section


**Step 6 — Video Assembly**

Combine:

audio
visuals
timing

Output = ready-to-publish video


**Step 7 — Upload / Storage**
YouTube / Drive / S3
store metadata (URL, topic, status)
What actually breaks (real issues)

**1. Garbage input → garbage output**

Automation scales mistakes.

If topics are weak:
→ system produces low-performing videos faster

**2. Generic AI scripts**

Without constraints:
→ repetitive + boring content

Fix:

enforce structure
control output length

**3. Timing + pacing issues**
long segments kill engagement
uneven pacing breaks flow

**4. System maintenance**

n8n workflows are powerful but require setup and maintenance as integrations evolve.


**Key insight**

This is NOT a video generation system.

It’s a content pipeline.

And the difference is:

Manual:
idea → create → edit → publish

System:
data → process → output → repeat


**Why this works**

“Top 10” content has:

fixed structure
repeatable format
predictable output

Which makes it ideal for automation.


**Final workflow (simplified)**
Idea
 → Generate script
 → Generate voice
 → Generate visuals
 → Assemble video
 → Publish


**Final thought**

Most people try to:

edit faster
script better
produce more

But the real leverage is:

Designing systems that produce content without you


**Question for devs**

Anyone here building automated content pipelines?

Curious about:

scaling workflows
handling quality control
avoiding repetitive outputs

Automate UGC Ad Videos with AI (Full Workflow + System Design)

Jayanth — Tue, 28 Apr 2026 16:54:45 +0000

What this builds

An automated pipeline that:

generates ad scripts
creates voice + video
outputs ready-to-use UGC ads

Architecture

`Input Idea
↓
AI Script Generator
↓
Voice Generation
↓
Video Generation
↓
Editing Layer
↓
Final Output`

Step 1 — Script Generation

Use LLM (Gemini / GPT)

Structure:

Hook
Problem
Solution
CTA

Step 2 — Voice Layer

TTS / cloned voice
keep sentences short
natural tone

Step 3 — Video Layer

avatar or stock visuals
sync with audio

Step 4 — Editing Layer

captions
transitions
pacing

What breaks

Long scripts
→ poor pacing
Generic output
→ low engagement
No structure
→ unusable video

Key insight

This is not video generation.

It’s content pipeline engineering.

Full breakdown with screenshot check here - UGC Ads 2025: Automate Videos With AI (Save 100+ Hours)

Use cases

ad creatives
content agencies
social media automation

Question

Anyone here using AI for ad creatives at scale?

Automate Blog Publishing with n8n + AI + WordPress (Full Workflow) published: true

Jayanth — Mon, 27 Apr 2026 14:31:45 +0000

What this builds

A complete automated blog pipeline:

fetch trending content
generate AI articles
create images
publish to WordPress

Architecture

`Scheduler (RSS)
↓
Filter topics
↓
AI content generation
↓
Image generation
↓
WordPress publish
↓
Tracking`

Step 1 — Fetch content (RSS)

pull from news sources
filter last 24 hours

Step 2 — Topic filtering

remove irrelevant content
keep niche-specific topics

Step 3 — AI blog generation

Generate:

title
intro
structured body
conclusion
SEO metadata

Step 4 — Image generation

generate featured image
attach to post

Step 5 — Publish via WordPress API

POST request:

json { "title": "Generated Title", "content": "AI content", "status": "publish" }





**Step 6 — Tracking layer**

Store:

topic
publish date
URL


**What breaks**
1. Generic content

Fix: enforce structure

2. Duplicate posts

Fix: tracking layer

3. SEO issues

Fix: add metadata + structure

For full breakdown with screenshot and workflow template check out [Automate Your Blog with AI : The Complete N8N News-to-WordPress Tutorial](https://elevoras.com/automate-your-blog-with-ai-the-complete-n8n-news-to-wordpress-tutorial/)

**Key insight**

This is not content generation.

This is content infrastructure.


**Use cases**

- niche blogs

- affiliate sites



**Question**

Anyone running AI content pipelines in production?

Curious about scaling + SEO impact.

Automate Instagram Comments with n8n + AI (Full Workflow + Real Issues)

Jayanth — Sun, 26 Apr 2026 11:03:16 +0000

What this builds

An automated system that:

monitors Instagram comments
generates contextual AI replies
optionally sends DMs
tracks everything

Basically:

comment → response → conversation → lead

Architecture

`Instagram Comment Trigger
↓
Fetch Post + Comment Data
↓
Filter (duplicates / spam)
↓
AI Response Generator
↓
Post Reply (Graph API)
↓
Send DM (optional)
↓
Store in DB / Google Sheets`

Step 1 — Trigger (Monitor Comments)

Use Instagram Graph API.

Setup:

poll every 2–5 minutes
fetch latest posts
extract new comments

Why polling?

Because real-time webhook setup is more complex and not required for most use cases.

Step 2 — Filtering Layer (Critical)

Before doing anything, filter:

already replied comments
duplicate users
spam comments

If you skip this:
→ your workflow will reply multiple times to the same user

Step 3 — Extract Context

From each comment, extract:

comment_text
username
post_caption

Why this matters:

AI without context → generic replies
AI with context → relevant replies


**Step 4 — AI Response Generation**

Input:

{{ comment_text + post_caption }}


System prompt example:

You are a helpful assistant replying to Instagram comments.

- Keep replies under 2 sentences
- Be natural and conversational
- Avoid generic responses
- Match context of the post

Output:

short reply
human-like tone
contextual response


**Step 5 — Post Reply**

Use Facebook Graph API:

POST /{comment_id}/replies

Payload:

{ "message": "AI generated reply" }



This posts directly under the comment.


**Step 6 — DM Automation (Optional but Powerful)**

Trigger DMs based on:

keywords (e.g. "price", "link")
or every comment

Examples:

send product link
send lead magnet
send onboarding message

This is where conversions actually happen.


**Step 7 — Tracking Layer**

Store data in:

Google Sheets
Airtable
Database

Track:

username
comment
reply_sent
dm_sent
timestamp

Why?

prevents duplicates
builds lead database
helps debugging


**What breaks (real issues)**
1. Duplicate replies

Cause:

no tracking

Fix:

always store processed comments
2. Generic AI responses

Cause:

no context

Fix:

include post caption + intent
3. API limits

Instagram Graph API has:

rate limits
permission restrictions

Fix:

throttle requests
batch processing
4. Delay vs real-time

Polling = delay (2–5 min)

Tradeoff:

simpler setup
good enough for most use cases


**Key insight**

Most people think this is an "automation problem".

It’s not.

It’s a context + control problem.

Bad input → bad replies → low engagement


**Where this is useful**
creators (engagement boost)
agencies (lead generation)
businesses (auto support)


**Final workflow (simplified)**
Comment
 → Filter
 → Generate reply
 → Post reply
 → Send DM
 → Store data


Anyone here running Instagram automation at scale?

Curious about:

rate limit handling
better DM logic
spam avoidance strategies

Drop your setup

Build a Voice Cloning Auto-Reply Bot with n8n + ElevenLabs (Real Workflow, Not Theory)

Jayanth — Sat, 25 Apr 2026 17:27:22 +0000

Most “AI voice bot” tutorials show the result.

Very few show what actually breaks when you try to build one.

This is a full working workflow using:

n8n (automation)
ElevenLabs (voice cloning)
AI model (response generation)

And more importantly , what you need to get right for it to actually work in real use.

What we’re building

A system that:

Receives a message
Generates a contextual AI response
Converts it into a cloned voice
Sends the audio back automatically

Use cases:

customer support automation
voice assistants
creator voice replies
agency workflows

Architecture

`Input (Webhook / App)
        ↓
AI Response (LLM)
        ↓
ElevenLabs (Text → Speech)
        ↓
Output (API / App / Messaging)`

Step 1 — Webhook (Input Layer)

In n8n:

Add a Webhook node
Enable POST requests

Example input:

`{
  "message": "Tell me about your service"
}`

Why webhook?

Because it allows:

app integrations
API triggers
scalable input

Step 2 — AI Response Layer

Add an AI node (OpenAI / OpenRouter).

Input:

`{{ $json.message }}`

System prompt (critical)

This is where most people mess up.

Bad:

long paragraphs
generic responses
no tone control

Good:

short replies
defined tone
controlled output

Example:

`You are a helpful assistant.

- Keep responses under 3 sentences
- Use natural conversational tone
- Avoid long explanations`

This directly affects voice quality later.

Step 3 — ElevenLabs Voice Generation

Use:

HTTP Request node
OR
dedicated integration
API structure (simplified):
POST https://api.elevenlabs.io/v1/text-to-speech/{voice_id}

`{
  "text": "{{ $json.output }}",
  "model_id": "eleven_multilingual_v2"
}`

Headers:

xi-api-key
content-type

Output:

audio stream / file

Step 4 — Output Layer

Options depend on use case:

return audio via API
send via WhatsApp / Telegram
attach in app
auto reply system

Example (basic API response):

`{
  "audio_url": "generated_audio.mp3"
}`

Full Workflow Logic

Webhook
→ AI Node
→ ElevenLabs
→ Response

What actually breaks (real issues)

Long AI responses = bad audio

Problem:

sounds robotic
unnatural pacing

Fix:

limit output length
enforce short responses

Latency issues

Flow delay:

AI response
voice generation

Result:

slow replies

Fix:

reduce token usage
optimize prompts
avoid unnecessary steps

Voice quality problems

Common issues:

inconsistent tone
unnatural pauses

Fix:

use clean training data
adjust ElevenLabs settings
test multiple voice configs

Cost scaling

You’re paying for:

AI tokens
voice generation

Bad setup:

long responses → higher cost

Good setup:

short + precise outputs
Important design insight

Most people think this is a “voice problem”.

It’s not.

It’s a text control problem.

If your text output is bad:
→ your voice output will be worse

Where this becomes powerful

Once stable, you can extend this to:

Multi-language voice bots
memory-based assistants
CRM integrations
lead qualification systems

Final thoughts

This workflow is simple on paper:

Text → AI → Voice → Output

But the quality depends entirely on:

how you control responses
how you handle latency
how you structure the flow

The difference between a demo and a usable system is in these details.

If you want the full breakdown check out - Build Voice Clone Bot : n8n + ElevenLabs Automation 2026

Question

Anyone here running voice-based automation in production?

Curious how you’re handling:

latency
scaling
real-time responses

Would love to compare setups 👇

Emergent AI Pricing Explained Credits, Plans & How Not to Waste Money

Jayanth — Fri, 24 Apr 2026 14:22:54 +0000

The credit problem nobody warns you about

If you're coming to Emergent from flat-rate tools — GitHub Copilot, Cursor, Replit's base tier — the pricing model will catch you off guard.
Emergent isn't $20/month = unlimited. It's $20/month = 100 credits. And credits are consumed every time the AI does work: generating a feature, debugging an error, refactoring a component, loading project context.
There's no upfront price list. No console that tells you "this prompt will cost 18 credits." You build, you spend, you find out at the end.

Here's the credit cost map I put together from actual usage:

`TASK                              CREDIT COST
─────────────────────────────────────────────
Landing page + contact form       10–20 credits
User authentication (OAuth)       25–40 credits
Multi-file debugging session      15–30 credits
Full styling refactor             30–50 credits
Stripe payment integration        35–60 credits`

The ranges exist because detailed prompts cost more than vague ones. "Add login" costs less than "Add login with Google OAuth, session management, error states, and post-auth redirect." Precision in your prompt = more computation = more credits.

Where credits actually disappear

Context loading scales with project size. Emergent reads your entire project before making changes — this is what enables it to modify multi-file logic correctly. But as your codebase grows, every action costs more because context is larger.

Debug loops are the silent budget drain. Identify bug → generate fix → test → secondary error → fix again. That's 30–50 credits per loop. Multiple loops on a complex bug can cost as much as building the original feature.

"Quick changes" aren't quick credit-wise. Asking for a small tweak on a large project still triggers full project context loading. There's no "lightweight mode."

The math that matters:

Standard breaks even with Pro at ~150 credits/month. Above that, Pro saves money per credit.
Team only makes sense for genuine multi-developer workflows. Solo builders pay ~$100/month for collaboration features they don't use.
Unused credits expire monthly. Don't over-subscribe. Start at Standard, track for 30 days, then decide.

The decision framework in code

`function pickEmergentPlan(monthlyCredits, teamSize) {
  if (teamSize >= 3) return "Team";
  if (monthlyCredits > 150) return "Pro";
  if (monthlyCredits > 0) return "Standard";
  return "Free (demo only)";
}

// Add 30% buffer for debugging
const estimatedCredits = featureCost * 1.3;
const plan = pickEmergentPlan(estimatedCredits, 1);`

Discount code

Before you pick a plan: ELEVORAS at checkout = 5% off Standard, Pro, and Team. Applies every billing cycle as long as your subscription is active. Cancel and resubscribe = need to re-enter.

vs. alternatives (developer perspective)
Replit: Better community, better for projects requiring real developer control. "Unlimited" throttles on heavy compute. Real cost at serious usage: $50+/month.

Bolt: No-credit flat rate is good for prototyping at volume. Lock-in is the problem — exporting a Bolt app to your own infra requires refactoring. Plan for that time cost.
Lovable: Superior reasoning for complex logic. $40/month for 200 credits. Worth it for production-grade apps where correctness matters more than speed.

Emergent's actual advantage for developers: Exported codebase is clean, readable, and deployable anywhere. No proprietary runtime. You own what you build.
Full breakdown + discount code at elevoras.com — link in bio.
Drop questions about specific use case credit costs below — happy to share the estimates.

Build a 24/7 Facebook Messenger AI Chatbot With n8n (Full Setup — No Code)

Jayanth — Wed, 22 Apr 2026 09:17:25 +0000

What this builds

A Facebook Messenger chatbot that responds to every incoming message automatically, 24/7, using an AI agent connected to your Facebook Business Page via n8n. Customers message your page — they receive an intelligent, context-aware reply within 30 seconds, whether you are online or not.

Workflow JSON download: Available on the blog

Architecture

`Facebook Messenger message received
        ↓
n8n Webhook (GET + POST — allow multiple HTTP methods)
        ↓
IF node — hub.mode = "subscribe" AND hub.verify_token = [your token]
  ├── TRUE → Respond to Webhook with hub.challenge (verification)
  └── FALSE → Extract message from POST body
        ↓
AI Agent node (OpenRouter)
  — reads sender ID + message text
  — generates contextual reply
        ↓
HTTP Request → Facebook Graph API
  POST /me/messages → send reply to sender`

Step 1 — Create your Facebook Developer App

Go to developers.facebook.com and create an account if you do not have one.
Click My Apps → Create App.

App configuration:

`App type:    Business
App name:    [Your Business] AI Assistant
Portfolio:   Select yours, or "No business portfolio selected"`

Important: Do not overthink the naming. You can modify everything later.

Step 2 — Switch app to Live mode (most tutorials skip this)

Your app starts in Development mode — only you can test it. Real customers cannot interact with it until you switch to Live.
Before switching, you need a Privacy Policy URL. Facebook verifies this automatically.
Fastest method: go to termsfeed.com → generate a free privacy policy → copy the URL.
In your app settings:

Find "Privacy Policy URL" field → paste your URL
Toggle the mode switch at the top from Development to Live

Without this step, your chatbot will only work when you are testing it yourself. All live customer interactions will fail silently.

Step 3 — Create the n8n webhook

Open your n8n dashboard → New Workflow → add a Webhook trigger node.
Critical settings in the webhook configuration:

`Allow Multiple HTTP Methods: ON  ← most people miss this
HTTP Method:                 GET and POST both selected
Respond:                     Using 'Respond to Webhook' Node`

The "Allow Multiple HTTP Methods" toggle is the setting that allows Facebook's verification handshake (GET request) and actual message delivery (POST request) to both hit the same webhook endpoint. Without this, you need two separate webhooks — and the verification fails.
Copy the Production URL from the webhook node. This is what you paste into Facebook next.

Step 4 — Add Messenger to your Facebook App

Back in your Facebook Developer dashboard:

Find the Products section → click Add Product
Find Messenger → click Set up

Inside the Messenger configuration:
Webhook settings:

`Callback URL:   [paste your n8n Production URL]
Verify Token:   AI-chatbot  (or any string you choose — you will need this exactly in Step 5)`

Click Verify and Save. Facebook sends a GET request to your webhook to confirm it is reachable.
Subscribe to message events:

`messages:        ON
message_reads:   ON`

Generate a Page Access Token:

Select your Business Page from the dropdown
Click Generate Token
Copy the token immediately — it only displays once
Store it securely — you need it in Step 7 to send messages back

Subscribe your page to the webhook by clicking Add Subscriptions next to your page name.

Step 5 — The verification handshake (where 90% of people get stuck)

Facebook verifies your webhook by sending a GET request with three query parameters:

`hub.mode          = "subscribe"
hub.verify_token  = [the token you set in Facebook]
hub.challenge     = [a random string Facebook wants echoed back]`

Your n8n workflow must respond with the exact value of hub.challenge. If it does not, Facebook rejects the webhook and nothing works.
Add an IF node after the webhook:

`Condition 1: {{ $json.query['hub.mode'] }}         equals  subscribe
Condition 2: {{ $json.query['hub.verify_token'] }}  equals  AI-chatbot
Both conditions must be TRUE`

On the TRUE branch — add a "Respond to Webhook" node:

`Respond with:  Text
Response body: [switch from Fixed to Expression]
Expression:    {{ $json.query['hub.challenge'] }}`

This echoes the challenge string back to Facebook, completing verification. Until this works, nothing else in the workflow can run.
Test it: Save the workflow, click Execute Workflow, then go back to Facebook and click Verify and Save on the webhook configuration. If verification fails, check that your IF conditions exactly match the parameters Facebook sends.

Step 6 — Extract the message from POST requests

When a customer sends a message, Facebook sends a POST request to your webhook with a JSON body. The message is nested inside:

`// Facebook Messenger webhook POST body structure
{
  "entry": [{
    "messaging": [{
      "sender": { "id": "SENDER_PAGE_SCOPED_ID" },
      "recipient": { "id": "YOUR_PAGE_ID" },
      "timestamp": 1234567890,
      "message": {
        "mid": "message_id",
        "text": "Hello, is this available?"
      }
    }]
  }]
}`

On the FALSE branch of your IF node (POST requests that are not verification), add a Set Fields node to extract what you need:

sender_id:    {{ $json.body.entry[0].messaging[0].sender.id }}
message_text: {{ $json.body.entry[0].messaging[0].message.text }}

These two fields feed into the AI agent.

Step 7 — AI Agent node

Add an AI Agent node. Connect OpenRouter credentials.

`Input:        {{ $json.message_text }}`

System prompt — paste this:

`You are a helpful customer service assistant for [Your Business Name].

You respond to Facebook Messenger messages from potential customers 
and existing clients.

Your tone: friendly, professional, helpful. Never robotic.

Key information about our business:
[Add: what you sell, your pricing if public, your hours, 
your location, your main services — whatever customers typically ask about]

If you cannot answer a specific question, tell the customer:
"I'll make sure [Name] gets back to you on this personally — 
usually within a few hours during business hours."

Never make up information you are not sure about.
Keep replies concise — 2-4 sentences maximum.`

Customise the system prompt for your specific business. The more specific the business information, the more useful the responses. Add your FAQs, your pricing tier (if public), your response time commitments, and any questions you regularly receive.

Step 8 — Send the reply via Facebook Graph API

`json
Add an HTTP Request node.

Method: POST
URL: https://graph.facebook.com/v18.0/me/messages
Headers:
Authorization: Bearer [YOUR_PAGE_ACCESS_TOKEN]
Content-Type: application/json

Body (JSON):
{
"recipient": {
"id": "{{ $('Set Fields').first().json.sender_id }}"
},
"message": {
"text": "{{ $json.output }}"
}
}

`
`

Replace [YOUR_PAGE_ACCESS_TOKEN] with the token you generated in Step 4.
The sender_id targets the reply to the specific person who sent the message. The $json.output contains the AI agent's response.

Step 9 — Activate and test

Toggle the workflow Active (top right — turns blue).
Open your Facebook Business Page. Send a message to your own page from a personal Facebook account. Wait 15–30 seconds. You should receive an AI-generated reply.
If no reply arrives, check the Executions tab in n8n. Each execution log shows exactly which node completed and where the flow stopped.

What breaks

Facebook verification fails repeatedly: Your IF node conditions are not matching Facebook's query parameters exactly. The parameters are case-sensitive: hub.mode and hub.verify_token with dots, not underscores. Also check that your Respond to Webhook node is on the TRUE branch, not the FALSE branch.

Messages arrive but no reply is sent: The Page Access Token has expired or is invalid. Facebook page tokens can expire — regenerate it from the Facebook Developer dashboard and update the HTTP Request node. Also confirm the token has pages_messaging permission.

AI Agent responds but Graph API returns 403: Your app does not have the pages_messaging permission enabled. Go to App Settings → Permissions and Features → search pages_messaging → Request permission.
Workflow triggers on your own page posts, not just messages: You subscribed to more events than needed. In Facebook Messenger webhook settings, ensure only messages and message_reads are enabled. Disable feed, comments, and other event types.

n8n receives POST but entry[0].messaging is undefined: Facebook occasionally sends other webhook event types (delivery receipts, echo messages). Add a second IF condition before the AI agent: check that $json.body.entry[0].messaging[0].message.text exists and is not null.

Running cost

OpenRouter with GPT-4 mini: approximately $0.001 per message response. 1,000 customer messages per month costs about $1.00 in API credits.
n8n: free self-hosted or free cloud trial.
Facebook API: free.

The entire chatbot infrastructure costs under $7/month for most small businesses — significantly less than a single missed client.
Workflow JSON at elevoras.com. Import directly into n8n and update the Page Access Token and verify token to your own values.

Building a variation with memory (tracking conversation history per user)? Drop it in the comments — that is the natural next step and happy to share the memory node setup.

Automate Personalized Cold Email Icebreakers With n8n, 0.3% to 10% Reply Rate

Jayanth — Tue, 21 Apr 2026 09:43:30 +0000

What this builds

An n8n workflow that takes a list of prospects from Google Sheets, scrapes each prospect's website (homepage plus up to 3 internal pages), uses AI to extract meaningful business insights from each page, generates a hyper-personalised multi-line icebreaker for each prospect, and writes the icebreaker back to the Sheet — ready for your outreach tool.

Output example:

`"Hey Katie, love how KTL Graphics makes it easy to filter by acreage — 
also a fan of your property update email option. Wanted to run 
something by you..."`

The system found acreage filtering and email notification features by actually crawling the website — not from the company name or LinkedIn headline.

Workflow JSON download: Available on the blog

Architecture

`Manual Trigger
        ↓
Google Sheets — get all rows
        ↓
Filter — only rows with email AND website URL
        ↓
Loop Over Items (batch size 1)
        ↓
HTTP Request — scrape homepage (HTML)
        ↓
Edit Fields — extract html field
        ↓
Code node — convert to string
        ↓
HTML Extractor — pull all <a href> links
        ↓
Edit Fields — keep: first_name, last_name, email, website_url, links
        ↓
Split Out — one row per link
        ↓
Filter — links starting with /
        ↓
Code node — normalise relative/absolute URLs
        ↓
Remove Duplicates + Limit (max 3 pages)
        ↓
HTTP Request — fetch each internal page
        ↓
HTML to Markdown conversion
        ↓
AI Agent — summarise each page into abstract
        ↓
Merge all abstracts
        ↓
AI Agent — generate icebreaker from all abstracts
        ↓
Google Sheets — write icebreaker back to prospect row`

Step 1 — Google Sheets setup

Export your Apollo.io leads (or any source) to Google Sheets.

Required columns:

`first_name | last_name | email | website_url | icebreaker (empty, filled by workflow)`

The workflow reads from this sheet and writes icebreakers back to the icebreaker column.

Step 2 — Filter node (quality gate)

Add a Filter node after the Sheets Get Rows node.
Two conditions, both must be true:

`Condition 1: website_url  exists and is not empty
Condition 2: email        exists and is not empty`

Without this filter, the workflow attempts to scrape blank URLs and throws errors that cascade through the rest of the pipeline.

Step 3 — Loop Over Items (batch size 1)

Add a Loop Over Items node.

Batch Size: 1

This processes one prospect at a time. Without it, the workflow tries to process all prospects simultaneously — rate limits on external sites cause failures, and the AI responses get mixed across prospects.

Step 4 — Scrape the homepage

Add an HTTP Request node.

`Method:      GET
URL:         {{ $json.website_url }}
Error handling: Continue on error
Redirects:   Follow, max 21`

"Continue on error" is critical. Some websites block scraping. Without this setting, one blocked site kills the entire workflow run.

Step 5 — Extract and normalise HTML

Add an Edit Fields node:

Field: html → string → {{ $json.data }}

Add a Code node:

`return [{
  json: {
    html: $json.html.toString()
  }
}];`

This converts the raw response body to a usable string

Step 6 — Extract all links from the homepage

Add an HTML Extractor node.

`CSS Selector:  a
Attribute:     href
Return:        Array
Options:       Trim values + clean text`

This pulls every link from the homepage — navigation, footer, internal pages. The homepage alone contains only part of the story. The About page, Services page, and Blog posts are where the personalisation gold lives.

Step 7 — Normalise URLs (Code node)

After splitting links into individual rows and filtering for links starting with /, add this Code node to normalise both relative and absolute URLs to relative paths:

`const items = $input.all();

const updatedItems = items.map((item) => {
  const link = item?.json?.links;

  if (typeof link === "string") {
    if (link.startsWith("/")) {
      item.json.links = link;
    }
    else if (link.startsWith("http://") || link.startsWith("https://")) {
      try {
        const url = new URL(link);
        let path = url.pathname;
        if (path !== "/" && path.endsWith("/")) {
          path = path.slice(0, -1);
        }
        item.json.links = path || "/";
      } catch (e) {
        item.json.links = link;
      }
    }
    else {
      item.json.links = link;
    }
  }
  return item;
});

return updatedItems;`

Why this is necessary: Websites use both relative links (/about) and absolute links (https://example.com/about). You need both normalised to the same format to deduplicate and combine with the base URL correctly in the next step.

Step 8 — Deduplicate and limit

Add a Remove Duplicates node (deduplicate on links field) followed by a Limit node:

`Max items: 3
Keep:      First Items`

Three pages per prospect is the sweet spot. Enough to find specific details, not enough to run up excessive API costs or hit rate limits on the target site.

Step 9 — Fetch internal pages

Add another HTTP Request node to fetch each filtered internal URL:

Method: GET
URL: {{ $json.website_url }}{{ $json.links }}
Error handling: Continue on error
`

The URL concatenates the base domain from the original lead data with the relative path extracted from the link list.

Step 10 — HTML to Markdown

Add an HTML to Markdown node:

`Mode:            HTML to Markdown
HTML:            {{ $json.data ? $json.data : "<div>empty</div>" }}
Destination Key: data`

Markdown is significantly more token-efficient than HTML for AI processing. Stripping HTML tags reduces the content you are passing to the AI model by 60–80%, which directly reduces API cost and improves the quality of the AI's analysis by removing noise.

Step 11 — AI page summariser

Add an AI Agent node with this system prompt:

You are a helpful, intelligent website scraping assistant.

You are provided a Markdown scrape of a website page.
Your task is to provide a two-paragraph abstract of what this page is about.

Return in this JSON format:
{"abstract":"your abstract goes here"}

Rules:

Your extract should be comprehensive — similar level of detail as an abstract to a published paper.
Use a straightforward, factual writing style.
Focus on what is unique or distinctive about this business or page.
Note any specific features, products, services, or differentiators that would be useful for personalised outreach.
Return ONLY the JSON object. No backticks. No explanation.

Model: GPT-4 mini via OpenRouter — approximately $0.0003 per page abstract.

Step 12 — Merge all abstracts

After the loop processes all three pages, merge the abstract outputs into a single node. Use a Merge node set to "Combine All Items."
Pass the merged abstracts to the final AI Agent.

Step 13 — Icebreaker generator

Add a final AI Agent node with this system prompt:

`You are an expert cold email copywriter specializing in personalized outreach.

You will receive multiple website page summaries for a prospect company.
Your task is to write a multi-line, personalized icebreaker for a cold email.

Rules:
- Reference 1-2 SPECIFIC details you found on their website
  (features, initiatives, content, language they use about themselves)
- Sound like you actually explored the website — not like you read a summary
- Be conversational, warm, and curious — not salesy
- Keep it to 2-3 sentences maximum
- Address the first_name directly at the start
- End with a natural transition into your pitch ("Wanted to run something by you...")

First name: {{ $('Loop Over Items').first().json.first_name }}
Website summaries: [all abstract outputs concatenated here]

Return ONLY the icebreaker text. No JSON. No explanation.
`

Step 14 — Write back to Google Sheets

Add a Google Sheets node:

`Operation:    Update Row
Match on:     email = {{ $json.email }}
Update:
  icebreaker: {{ $json.icebreaker }}`

The icebreaker column fills in for each row as the workflow processes it. When the run is complete, your Sheet has a personalised icebreaker for every prospect with a valid website URL.

What breaks

HTTP Request returns 403 on most sites: The site is blocking the default n8n user agent. Add a custom header: User-Agent: Mozilla/5.0 (compatible; outreach-research/1.0). This passes most basic anti-scraping checks.
AI Agent returns a JSON error instead of abstract: The page content was empty (HTTP request returned an error page). The {{ $json.data ? $json.data : "

empty" }} expression in the HTML to Markdown node handles this — it passes a dummy div instead of null, which prevents the AI from throwing on empty input.

Loop produces mixed data across prospects: You are not using batch size 1. Set Loop Over Items batch size to exactly 1.
Icebreakers sound generic despite the workflow running: The AI is receiving summaries but not finding distinctive details. Check your Limit node — if it is set to 0 or is missing, you may only be scraping the homepage. Set it to 3 to ensure About and Services pages are included.

Running cost

OpenRouter GPT-4 mini: approximately $0.002 per prospect (3 page abstracts + 1 icebreaker generation).
100 prospects = $0.20 in API costs.
1,000 prospects = $2.00.

Compare this to $5–$50 per manually researched and written personalised opener. The cost case is immediate.
Workflow JSON at elevoras.com.
What niche are you targeting with cold outreach? Drop it in the comments — happy to suggest prompt adjustments for specific industries.