DEV Community: Łukasz Blania

I got tired of paying for form backends, so I built my own

Łukasz Blania — Wed, 08 Apr 2026 09:57:47 +0000

A buddy of mine does freelance web dev. Mostly small business sites -- restaurants, dentists, that kind of thing. Every single client needs a contact form. And every single time it's the same conversation: "Why am I paying $20 a month just to get emails from my website?"

Fair question honestly.

His solution was to rig up an n8n workflow that catches form submissions via webhook and dumps them into a Google Sheet. It works. Technically. Until a column shifts, or the webhook URL expires, or the client wants to see their submissions somewhere that isn't a spreadsheet.

I kept thinking about this. A form backend is such a basic thing. You receive a POST request. You save it. You send a notification. Maybe you show it in a dashboard. That's it. That's literally the whole product. And yet Formspree wants $20/mo for it. Basin, Formcarry -- same ballpark.

So around December last year I decided to just build the thing myself.

The building process

I should mention -- this was always a side project. I run a small automation agency during the day, so FormTo got evenings and weekends. Some weeks I'd grind on it for hours, other weeks I barely touched it. That's just how side projects go I guess.

The backend came together pretty fast. Fastify, PostgreSQL, standard stuff. I used Claude Code a lot during development and honestly it was a game changer for velocity. Stuff that would normally take me a full evening to figure out -- like getting JWT auth right, or writing all the database migrations, or setting up the Caddy reverse proxy config -- I could knock out in an hour or two. Not saying AI wrote the whole thing, but it definitely cut the timeline by half, maybe more. For a solo dev working on nights and weekends that matters a lot.

The frontend though. That's where things got interesting.

The Upwork disaster

I'm primarily a backend guy. I can hack together a React app but I'm not going to pretend I'm a frontend specialist. So I thought OK, let me hire someone on Upwork to build a clean dashboard UI. Found a guy, decent portfolio, good reviews. Gave him the designs, explained the API, set up the repo.

What a disaster.

The first delivery was basically a template he found somewhere with my API calls shoved in. Half the components didn't work. State management was all over the place. I spent more time reviewing and fixing his code than it would have taken me to write it from scratch. After two rounds of revisions that somehow made things worse, I just paid him for the hours and moved on.

Ended up building the frontend myself with Claude Code again. Took me about two weeks to get something I was actually happy with. React 19, Tailwind v4, Radix UI for the component primitives. Is it the most beautiful dashboard ever? No. But it works, it's consistent, and I understand every line of code in it. That Upwork detour cost me about a month of progress and a few hundred dollars for code I threw away entirely.

Lesson learned: if your project is small enough and you're technical enough, just build it yourself. Hiring makes sense when you're scaling, not when you're prototyping.

So what is FormTo actually?

FormTo is a self-hosted form backend. You take any HTML form, point the action attribute at your FormTo instance, and submissions start showing up in a dashboard. No JavaScript SDK, no API keys, no build step.

<form action="https://forms.yourdomain.com/f/contact-abc123" method="POST">
  <input name="name" required />
  <input name="email" type="email" required />
  <textarea name="message"></textarea>
  <button type="submit">Send</button>
</form>

I only built stuff I actually needed or my friend kept asking for. Notifications go to email (any SMTP), Telegram, Slack, or a generic webhook -- so you can still pipe it to n8n or Make if that's your thing, but you don't have to anymore. There's spam handling with honeypot fields and rate limiting instead of CAPTCHAs because nobody likes CAPTCHAs. Auto-close after X submissions or a date, which turned out to be really handy for RSVPs and waitlists. CSV export because someone will always ask for a spreadsheet, it's like a law of nature at this point. And hosted form pages if you don't even want to write HTML -- just share a link and you're done.

Running it

The whole thing runs on Docker Compose. One command and you've got a working form backend with automatic HTTPS via Caddy. There's a first-run wizard so you don't need to mess with config files beyond setting a domain and database password. It runs fine on a $5 VPS.

git clone https://github.com/lumizone/formto
cd formto
cp formto.env.example formto.env
docker compose up -d

One thing I want to be clear about -- this is not a form builder. No drag-and-drop, no visual editor, no templates. You write your form however you want and point it at FormTo. That's intentional. There are a million form builders out there already. I just wanted the backend part done well.

Open source + cloud

It's open source under AGPL-3.0. The full feature set is right there, nothing held back behind a paywall or a pro tier. I'm also working on a cloud version at formto.dev for people who don't want to deal with servers, but the self-hosted version will always be the complete product. No artificial limits to nudge you toward paying.

GitHub: github.com/lumizone/formto

It's still early and I'm the only one working on it. If something breaks, if you want a feature, or if you just want to tell me the UI is ugly -- open an issue. I read all of them.

How AI Can Finally Write B2B Outreach Emails That Actually Work

Łukasz Blania — Sun, 07 Sep 2025 17:40:30 +0000

Cold emailing has always been a strange mix of art and science. On one hand, it’s about persuasion, psychology, and human connection. On the other, it’s a numbers game — you need enough volume to cut through the noise and land in front of the right people.

For years, founders, marketers, and sales reps have been caught in the same dilemma: personalize every email manually and burn endless hours, or send generic templates at scale and watch reply rates crash to zero.

When AI burst onto the scene, many people thought the problem was solved. “Just let ChatGPT write your emails!” But anyone who tried quickly discovered the ugly truth: most AI-generated emails sound painfully robotic, overloaded with buzzwords, or so vague they could apply to any business on the planet.

So why does AI stumble so badly at something as simple as writing a cold email? And more importantly, how do we fix it?

Why AI Struggles With Email Outreach

AI’s weakness comes down to context. Large language models are designed to be general-purpose — they can write code, explain history, summarize legal documents, and yes, write emails. But that flexibility comes at a cost.

Think of it like buying a single machine that tries to function as a fridge, oven, washing machine, coffee maker, and television all at once. Technically, it can do all of those things. But if you want the perfect sourdough baked at 230°C? Or a rich espresso brewed at 8 bars of pressure? That multi-tool monster won’t cut it.

Email outreach requires precision. You need the right tone, the right length, the right level of personalization, and a clear value proposition. It’s not enough for the text to “look okay” — it has to feel like it came from a human who understands the recipient’s problems.

When you ask AI:
“Write me a cold email to a marketing agency.”

It fills in the blanks with generic business language. You get lines like:
“We offer innovative solutions to help your business thrive in today’s competitive landscape.”

It looks polished. But it’s the kind of sentence that 10,000 other emails also contain. And in the real world, that means instant delete.

Structure: Giving AI a Map to Follow

Here’s the first key: AI performs best when you don’t just give it a vague request, but a map. Structure is the difference between usable output and robotic nonsense.

Think of sending instructions to AI like shipping a package:
If you throw your product, address, and label separately into the sky, maybe — by pure chance — it lands in the right place.
But if you pack it carefully, seal the box, and give it to a courier with clear delivery instructions, you know it will arrive exactly where it should.

AI is the same. If you tell it “write me a cold email,” it’s guessing. But if you hand it a proven structure and specific guidelines — suddenly, it becomes a precision tool.

Here’s an example skeleton I use in real campaigns:
{{name}},

{{icebreaker}}
Everyone in [[niche]] is leaking cash, slow intake, lost follow-up, clunky admin., all bottlenecks AI actually kills. No fancy buzzwords. This is about running tighter, faster, and never missing a chance to win deals or lock in repeat buyers.
{{name}}, spotted gaps you can close for good. Most never even spot the leaks. Want the straight playbook or staying stuck? Reply yes or no, nothing else.
[[YourName]]

This structure forces clarity. It starts with a hook (the icebreaker), names specific problems the recipient actually feels, and ends with a simple binary CTA. No long-winded pitch, no corporate jargon, no desperate begging for attention.

When you feed AI this structure and add rules like “do not use the word synergy” or “keep it under 120 words,” the difference is dramatic. Instead of generic fluff, you get concise, sharp outreach that feels human.

Personalization: The Real Game-Changer

Templates are useful, but they’re just the skeleton. The muscle of a great outreach campaign is personalization. Without it, even the best structure falls flat.

Think about your own inbox. If you get a message that clearly went to 500 other people, you delete it without reading. But if someone references your company, your latest LinkedIn post, or a pain point you actually deal with, you pause. You might even reply.

AI can do personalization at scale — but only if you feed it the right inputs. That means giving it data such as:

Who the recipient is: job title, role, decision-making power.
What the company does: industry, recent projects, unique positioning.
What’s happening now: case studies, blog posts, product launches, LinkedIn updates.
Your specific angle: how your offer relates directly to their situation.

Here’s the key: AI doesn’t guess well. If you don’t give it this information, it will invent generic filler. But if you provide real context, it can weave it into your email in ways that feel personal and authentic.

Yes, you could technically research and write this by hand. For five prospects, sure. For fifty, it starts getting painful. For five hundred? It’s impossible without burning out. And that’s where automation becomes essential.

Automating the Grind With AI + n8n

This is where outreach stops being a chore and becomes a system. By combining AI with automation platforms like n8n, you can run campaigns that are personalized, scalable, and efficient.

Here’s how it looks in practice:

Google Sheets — load in your prospect list. Maybe it’s 1,000 contacts pulled from LinkedIn Sales Navigator.
Anymail Finder — automatically fetches and verifies the correct email addresses. You only pay for valid ones, so there’s no wasted budget.
Perplexity — pulls in live web data for each prospect, so you have current, relevant details to use for personalization.
OpenAI — writes the emails using your structure, style rules, and the personalized data you collected.
n8n — stitches everything together, runs it in sequence, and outputs emails that are ready to send.

The best part? Once you set this up, you’re no longer chained to your laptop, spending nights crafting line after line. The system runs in the background. You wake up the next morning, and your outreach campaign is already written and queued.

Instead of drowning in repetitive work, you focus on what actually matters: conversations with prospects who are ready to buy.

Results From the Field

When I tested this system, here’s what happened over a 3-week campaign:

Delivery rate: 99%
Bounce rate: 1%
Open rate: 54%
Click-through rate (CTR): 18%
Prospects amount: 300
Emails per person: 5 (4 follow-up)

And the craziest part? I spent maybe 4 hours total. That time was used for setup: preparing the email footer, creating the prospect list, and configuring the workflow. The rest ran automatically.

Normally, you’d need a full sales development team for those results. With AI and automation, one person can achieve the same — without sacrificing evenings, weekends, or sanity.

Why This Matters More Than Ever

It’s tempting to dismiss all this and say: “I’ll just write emails myself.”

And for small-scale outreach, you’re right. If you’re sending 5 emails to potential partners, don’t overthink it. But scale changes the equation.

Cold email is fundamentally about volume. The law of large numbers applies — you need to reach enough people for opportunities to materialize. But pure volume without personalization is spam. And pure personalization without automation is impossible to sustain.

AI gives you the middle ground: volume with personalization. Instead of choosing between quality and quantity, you finally get both.

This isn’t just a productivity hack. It’s a competitive edge. Companies that figure out how to combine AI with outreach workflows will simply outpace those who don’t. They’ll send more messages, book more calls, and close more deals, all while spending less time in the weeds.

Final Thoughts

AI isn’t magic. If you just open ChatGPT and type “write me a cold email,” you’ll get the same robotic junk everyone else is sending. That’s why so many people conclude that AI “doesn’t work for outreach.”

But the truth is different. AI works brilliantly when you give it structure, feed it personalization, and connect it to automation tools that handle the heavy lifting.

Think of it like this:

On its own, AI is a brilliant but unfocused intern. It has potential but doesn’t know what you want.
With guidance (structure), it becomes a competent writer.
With resources (personalized data), it becomes persuasive.
And with automation, it becomes a full-scale outbound team that never sleeps.

That’s the power shift. You stop being limited by hours in the day and start running outreach at a scale that would normally require a small army.

I’ve packaged my exact workflow so you don’t have to reinvent the wheel. You can grab it here:

My n8n Workflow

AI isn’t about replacing human skill. It’s about multiplying it. And in B2B outreach, that multiplier can be the difference between sending a handful of emails that get ignored — and running a campaign that actually drives deals.

PS: “I sent” over 600 emails walking on the Mountains, for a whole week, found 4 clients, and spent a great time ;)

ChatGPT-5 Is Amazing. You don’t know how to use this properly. I show you why.

Łukasz Blania — Sun, 07 Sep 2025 10:11:00 +0000

Let’s talk like humans for a second. You typed a vague thought into a text box, hit Enter, and expected cinematic genius to roll out of the machine like a red carpet. Instead, you got something… meh. You sighed. “ChatGPT-5 is worse than 4o!” you posted, shaking your fist at the cloud.

I’ve got news that will both empower you and mildly annoy you: GPT-5 is better than GPT-4o for most real work — agents, tool use, coding, long context, instruction following — but it punishes sloppy prompts more than its predecessors. The model is more steerable, more systematic, and far more literal. If you tell it where to go, it’ll drive. If you say “take me somewhere nice,” don’t be surprised when you end up in a parking lot with decent lighting.

This article is a friendly deep-dive into how to get consistently great results with GPT-5. We’ll quickly cover what changed from the GPT-4o era, why your results might feel bland, how the new modes (Instant, Auto, Thinking, and Pro) actually work, and a handful of practical snippets — straight from the playbook of people who use GPT-5 all day — to help you write prompts that don’t waste tokens or time.

Grab a coffee. I’ll keep it conversational, a little dry-humored, and very practical.

What Changed: From a Zoo of Models to One Agentic System

In the GPT-4o days, you often had to choose your fighter — a model for speed, another for multimodal, another for reasoning, and so on. GPT-5 simplifies that mental overhead. Think of it less like “a model” and more like an agentic engine with multiple gears:

A unified core (one flagship model) that routes internally.
Modes that change how hard it thinks and how verbose it speaks.
Agent-first behavior: better at calling tools, following rules, and persisting plans across steps.
Stronger instruction adherence: if your instructions conflict or are vague, GPT-5 will spend effort reconciling that mess instead of producing gold from chaos.

The practical effect is: less menu anxiety, more steering power. But you have to actually steer.

“My Results Are Terrible” — Why That Happens with GPT-5

Let’s get the uncomfortable bit out of the way: GPT-5 is allergic to ambiguity. GPT-4o was often forgiving. You could toss a fuzzy prompt at it and it would do a decent job guessing your intent. GPT-5 can still guess — but it’s trained to respect your constraints and follow your process when you give it one. When you don’t, it can over-invest in clarification or under-deliver because the target was never pinned down.

Here are the three most common causes of “bad answers” with GPT-5:

Vague goals
- “Write a plan” is not a goal.
- “Draft a 7-step launch plan for a two-person SaaS, each step ≤120 words, with a simple checklist and a 14-day timeline” is a goal.
Contradictory rules
- “Never ask the user to confirm anything” vs. “Always obtain explicit consent before booking” is the kind of conflict that sends GPT-5 into polite paralysis. It tries to satisfy both. Resolve conflicts yourself.
Missing stop conditions
- Agents need to know when to stop. If you don’t define finish lines, they’ll keep circling the track — or stop too early. You decide the lap count.

The fix: be explicit about what you want, how you want it, how far the model should explore, and when it’s allowed to proceed despite uncertainty.

The Modes: Instant, Auto, Thinking, Pro — What They Actually Do

GPT-5 exposes four working styles. These aren’t just “speed settings”; they’re behavior contracts. Use the right one for the job, and your life gets easier.

1) Instant — “Answer fast, don’t overthink it”

Instant mode is the one that answers as quickly as possible, often sacrificing depth and nuance to give you something fast and usable. It shines when the task is simple — like rewriting a sentence, summarizing a short passage, or giving a factual answer — but it won’t bother with complex reasoning or edge cases. If you ask it to solve a real problem, it will simply hand you the quickest version of an answer and move on.

When to use:

Quick summaries, short emails, simple rewrites, straightforward Q&A.
Latency-sensitive interfaces (chat widgets, quick drafts).
You already know what you want; you just need it formatted or rephrased.

Strengths:

Low latency, low cost.
Great when the task is clear and bounded.

Pitfalls:

Doesn’t wander far. If the task is fuzzy, Instant will give you a tidy version of your fuzziness.
Minimal context gathering; it won’t go spelunking unless told.

How to prompt for Instant:
Why this works: you’ve set a tiny budget, a clear finish line, and a crisp format. Instant thrives on constraints.

Search depth: very low
Absolute max tool calls: 2
Proceed with the best available answer even if not fully certain.
Stop when output meets the format and constraints below.

Audience: startup founders, non-technical
Length: ≤ 180 words
Format: 3 bullets + 1-sentence CTA
Tone: concise, friendly, no fluff

2) Auto — “Pick the right depth for me”

Auto mode is the balanced choice. It adapts to the difficulty of the task, behaving like Instant when things are straightforward, but taking more time and reasoning when the problem requires it. This makes it the most practical mode for everyday use, because you don’t have to decide how much thinking the model should do — it figures it out on its own. The catch is that if your instructions are vague, Auto might overanalyze and spend too much time gathering context before giving you what you want.

When to use:

Most day-to-day tasks where you don’t want to micromanage.
The model can decide whether to think shallow or deep.
You’re okay with it calling tools and making a plan if needed.

Strengths:

Balanced. Often the best default.
Can switch gears mid-task: skim where trivial, dig where tricky.

Pitfalls:

If your instructions are vague, Auto might “gather context” longer than you expected.
If your rules conflict, Auto burns cycles reconciling them.

How to prompt for Auto (calibrated):

Goal: get just enough context to act.
Method:

Start broad, then one focused batch of subqueries.
Deduplicate; cache; avoid repeated searches. Early stop:
You can name exact items to change or produce. Escalate once:
If signals conflict, do one refined batch, then act. Keep going until all subtasks in the plan are done. Do not hand back on uncertainty—proceed with the most reasonable assumption, and document it in the summary.

3) Thinking — “Take your time, reason deeply, chain steps”

Thinking mode is where GPT-5 goes deep. Instead of rushing, it breaks the problem apart, makes a plan, and follows through step by step. This mode is built for accuracy, analysis, and complex reasoning. It’s slower and more expensive, but if you want a model that can handle multi-step research, write thorough strategies, or work inside large codebases, this is the gear you want. Without clear instructions, however, it can end up overthinking and generating more than you bargained for.

When to use:

Complex multi-step problems, long-horizon tasks, architecture, tricky analysis, non-trivial refactors, research synthesis.
Anywhere accuracy, edge cases, and planning matter more than speed.

Strengths:

The highest quality reasoning and decomposition.
Excellent at following multi-stage processes and double-checking work.

Pitfalls:

Slower and more expensive.
If you don’t set stop conditions, it may over-invest in “thoroughness.”

How to prompt for Thinking (with guardrails):

Decompose the request into a numbered plan (max 7 steps).
Before executing, validate the plan against constraints and risks.
After each step, self-check: does this meet the acceptance criteria?
Output passes all format checks.
No TODOs or placeholders remain.
Edge cases addressed: [list your edge cases].
Total tool calls: ≤ 6 unless a blocker is detected.
If a blocker is detected, explain briefly, then request explicit permission to exceed. Pro move: pair Thinking with the Responses API and reuse previous_response_id across turns. This preserves the model’s plan/context without re-paying for it each time.

4) Pro — “All-in performance with ”

Pro mode is the perfectionist. It doesn’t just think deeply like the Thinking mode, it also packages the result neatly, with polish, structure, and presentation. This makes it the mode for high-stakes tasks: executive memos, legal drafts, detailed proposals, or anything where you want the output to look like it came from a professional rather than an assistant. It is the slowest and most resource-intensive option, and sometimes it’s simply overkill, but when the final product matters, this is the mode that delivers.(Only available in pro plan(200$/month))

When to use:

High-stakes deliverables where both the thinking and the final writing must be excellent: investor memos, legal policy drafts, system designs pitched to executives, production-grade code proposals.
Scenarios where tone, formatting, and completeness are part of the spec.

Strengths:

Combines depth with editorial quality and strong instruction adherence.
Great at keeping the big picture while nailing the details.

Pitfalls:

Overkill for quick tasks.
If your prompt is vague, you’ll pay more to get a beautifully formatted shrug.

How to prompt for Pro (quality spec):

Structure: executive summary → details → risks → next steps.
Evidence: cite sources or assumptions inline; mark assumptions clearly.
Style: plain English, active voice, short paragraphs.
Review pass: do a final contradiction scan; align with acceptance criteria.
Provide a clean deliverable plus a 5-line TL;DR.
Include a checklist the reader can act on immediately.

Prompt Patterns That Work in GPT-5 (And Why)

1) Contracts beat vibes

Define output contracts, budgets, stop conditions, and escape hatches (“Proceed even if not fully certain”). GPT-5 respects contracts.

2) Remove contradictions at the source

If your process has a real exception (“In emergencies, skip patient lookup and give 911 guidance”), write that exception explicitly. The model is obedient; don’t make it choose between rule parents.

3) Use “tool preambles” to keep humans oriented

If your agent will run multiple steps or edit files, have it front-load the plan and narrate progress succinctly.

Rephrase the user goal briefly.
Outline a step-by-step plan.
Announce each tool call and why.
Summarize: planned vs. completed. 4) Control eagerness, don’t just complain about it Too much “research”? Tighten <context_gathering>. Too many clarifying questions? Add <persistence> and tell it to assume and proceed.

5) Verbosity is a dial

There’s a verbosity parameter (final answer length) and your prompt can override it locally. For instance: global verbosity: low, but inside code tools ask for “high verbosity” diffs and comments. You’ll get tight narration, but richly explained code edits.

Practical Snippets You Can Paste Today

A. The “Atomic Task” Skeleton (great for Instant/Auto)
Task: Rewrite the following draft into a 120–150 word LinkedIn post for non-technical founders.
Include: a hook (1 sentence), 3 value bullets, 1 CTA sentence.
Constraints: avoid buzzwords; no hashtags; plain English.
Stop when: length and structure are satisfied.
If uncertain: proceed with best-effort and leave a one-line note of assumptions at the end.
Draft:
[PASTE]

B. The “One-Batch Research” Guardrail (Auto)
<context_gathering>

Run exactly one parallel batch of searches.
Read top 3 hits per query; deduplicate.
Early stop when ~70% of sources converge on the same answer.
No second batch unless a contradiction blocks action. </context_gathering>

C. The “Thinking Pass” for Complex Work
<planning>
1) Draft a mini-rubric (hidden) with 5–7 criteria for excellence.
2) Produce a numbered plan (≤7 steps) to satisfy the rubric.
3) Execute step-by-step; after each, self-check against the rubric.
4) At the end, summarize residual risks or uncertainties.
</planning>

D. The “Code Edit Rules” (Frontend example)
<code_editing_rules>

Clarity first: descriptive names, small components, minimal props.
Consistency: Tailwind spacing multiples of 4; 1 neutral + ≤2 accents.
Stack defaults: Next.js (TS), Tailwind, shadcn/ui, Lucide, Zustand.
Directory: /src/app, /components, /hooks, /stores, /lib, /types.
Deliverables: a focused diff + short rationale + test notes. </code_editing_rules>

E. The “Finish Line” Contract (for any mode)
<acceptance_criteria>

Format exactly as specified below.
No placeholders or TODOs.
Edge cases addressed: [list].
Final: a 5-line TL;DR the reader can act on. </acceptance_criteria>

Cookbook-Style Moves (Lifted from Real Usage)

1) Persist reasoning between steps (Responses API)

When your agent must call tools across turns, reuse previous_response_id. You’ll avoid “re-planning tax” and keep latency sane on long tasks.

2) Minimal Reasoning ≠ Minimal Guidance

If you choose minimal/low reasoning for speed, compensate with more explicit planning in the prompt. Example: ask the model to output a 4-bullet “what I’m about to do” before it does it. Your bullets become its scaffolding.

3) Calibrate questions vs. assumptions

If you hate clarifying questions mid-flow, say so:
“Do not hand back to the user for confirmation; make the most reasonable assumption and proceed. Document assumptions at the end.”

4) Prefer local verbosity overrides

Short final answers, verbose code diffs. Or vice versa. Tell it where to spend words.

5) Use metaprompting to improve your prompt

Stuck? Ask GPT-5: “Given this prompt and this undesired behavior, what minimal edits would you make to elicit [desired behavior]?” You’ll get direct, actionable nips and tucks instead of a full rewrite.

A Guided Tour: Matching Tasks to Modes

Task	Mode	Why	Prompt Tip
Rephrase email, fix tone	Instant	Clear target, low risk	Define length, audience, tone, and stop condition
Draft landing page copy	Auto	Some thinking, some speed	Provide section outline + word budgets per section
Compare 3 vendor APIs, decide	Thinking	Research + synthesis + decision	One-batch research + acceptance criteria + TL;DR
Large refactor (multi-file)	Thinking/Pro	Planning, code quality, diffs	Code rules + plan + test notes + finish line
Exec memo with risks & next steps	Pro	Quality + polish + structure	Quality bar + handoff checklist
Bug triage in a repo	Auto → Thinking if complex	Start lean, deepen if needed	Plan first; escalate only once

Fixing the Five Classic Anti-Patterns

“Write me a strategy”
- Better: “Write a 7-step GTM strategy for a 2-person SaaS selling a $29/mo analytics add-on to Shopify stores. Each step ≤120 words; include risks and a day-by-day 14-day plan.”
“Be creative but concise but also very detailed”
- Pick a lane. If you must blend: “Use crisp, concrete language; short paragraphs; examples over adjectives. Max 500 words. Include 2 concrete examples.”
“Summarize this PDF” (no audience)
- Better: “Summarize for CFO who needs to decide by Friday. Extract 3 numbers, 3 risks, 3 upside factors. Max 200 words + 5-line TL;DR.”
“Improve the code” (no definition of “improve”)
- Better: “Refactor for readability and testability: extract components, remove dead code, add 3 unit tests. Keep behavior identical. Explain diff in 5 bullets.”
“Research everything about X”
- Better: “Run one batch of searches; read top 3 results; stop when sources converge. Produce a 10-bullet executive summary + links + open questions.”

Tiny Prompts That Save Hours

“Assume don’t ask” switch:
- “Do not ask for clarifications mid-task. When uncertain, choose the most reasonable assumption, proceed, and log assumptions in the final summary.”
“Don’t wander” leash:
- “Limit context gathering to one batch; no second batch unless contradictions block progress.”
“No fluff” pressure:
- “Plain English. No metaphors. No analogies unless requested. Replace adjectives with numbers or examples.”
“Rubric-first build” for greenfield:
- “Before building, silently create a 6-point rubric for a world-class [deliverable]. Use it to self-check each step; do not show the rubric.”
“Finish line” clarity:
- “Stop only when the deliverable meets the acceptance criteria; otherwise continue iterating.”

A Word on Tone, Humor, and Human-ness

You’ll notice GPT-5 can feel a little… serious. If your audience expects warmth or punch, ask for it:

“Friendly, lightly humorous tone.”
“Speak directly to the reader (‘you’), like a helpful colleague.”
“Short paragraphs. Occasional one-liner for levity.”

And if you want zero fluff: say “No jokes, no rhetorical questions.” The model will comply. It’s obedient, not psychic.

Putting It All Together: A Mini Playbook

Choose the model:
- Instant: quick, bounded tasks.
- Auto: default for most.
- Thinking: complex, multi-step, accuracy-critical.
- Pro: high-stakes, polished deliverables.
Define the deliverable:
- Audience, length, structure, constraints, finish line.
Steer eagerness:
- <context_gathering> for budgets and early stops.
- <persistence> for autonomy and fewer clarifying questions.
Specify quality:
- <quality_bar> and <acceptance_criteria>.
- Verbosity rules (where to be terse vs. detailed).
Use tool preambles:
- Plan → narrate → summarize. Humans love to see the map.
Persist reasoning across turns:
- Responses API + previous_response_id. Pay once, reuse the plan.
Keep prompts contradiction-free:
- Resolve rule conflicts up front. Explicit exceptions beat implicit hope.
Iterate:
- When results disappoint, ask GPT-5 to propose minimal prompt edits to reach your desired behavior. Ship the improved version.

The Punchline Without the Punch

If GPT-4o was your friendly generalist who tried to read your mind, GPT-5 is your meticulous colleague who will do exactly what you asked — and look at you expectantly if what you asked was unclear. It’s smarter, more persistent, and wildly capable. But it is not a magician. Vague in, vague out.

Write contracts, not vibes. Choose the right mode. Set budgets and finish lines. Give it a quality bar to clear and an escape hatch when uncertainty isn’t worth the wait. Do that, and GPT-5 stops feeling “worse than before” and starts feeling like the teammate you brag about.

If you still want “somewhere nice” without directions, I hear the parking lot has great lighting.

SEO is dead, RAO just doesn’t know it yet

Łukasz Blania — Sun, 24 Aug 2025 14:36:25 +0000

The End of Traditional SEO: Enter Retrieval-Augmented Generation (RAO)

For years, SEO meant keywords, backlinks, and chasing Google's ever-shifting algorithm. But beneath the surface, a revolution is brewing—one that many developers and marketers haven't fully grasped yet. The rise of Retrieval-Augmented Generation (RAO) is silently reshaping how content is discovered, accessed, and consumed. In this landscape, static, keyword-stuffed pages are losing relevance to dynamic content pipelines that fetch and fuse live knowledge into AI-generated responses.

What Is Retrieval-Augmented Generation?

At its core, RAO enhances AI by providing real-time, relevant information from external databases or the web during content generation. Instead of relying solely on pre-trained models or static content, RAO connects AI models with live data, delivering custom, accurate, and up-to-date answers tailored to the user’s context.

Dynamic Knowledge Injection: Pulls facts or datasets as needed.
Context Awareness: Adapts responses based on retrieval results.
Personalization: Generates content that fits user intent more precisely.

This breaks the traditional content creation mold, where SEO optimized for search engines often meant compromising clarity or relevance for ranking.

Why Traditional SEO Is Losing Its Edge

The Limits of Keyword-Centric Content

Keyword stuffing and link building were once the bread and butter of search success. Now they often lead to poor user experience and can be penalized by search engines. More importantly, they can't compete with content that actually answers specific, dynamic queries instantly.

Search Engines Evolve

Search platforms increasingly leverage AI and live data integration. They prioritize relevance and real-time answers over static page authority.

User Expectations Shift

Users demand immediate, precise, and personalized information, not just a list of links optimized to rank.

How RAO Changes the Game With Automation and AI Workflows

Integrating RAO into your development and content strategy is not just a concept—it's actionable through automation and AI pipelines.

Step-by-Step:

Connect to Live Data Sources: APIs, databases, or web scraping to gather fresh information.
Trigger AI Prompts Dynamically: Feed live data into AI models during content generation rather than relying on static inputs.
Automate Content Delivery: Use workflow automation tools like n8n to orchestrate data retrieval, AI prompting, and content publishing.

This approach ensures every piece of content is as relevant and updated as possible, directly improving discoverability and user satisfaction.

Real-World Example: Workflow Automation with n8n

To put theory into practice, I published a workflow that plugs live web data into AI prompts for dynamic content creation. This hands-on integration highlights how RAO can be applied effectively in modern development environments. Explore it here:

Workflow: Blog content machine

This solution tackles the pain points of stale content and manual updating, enabling continuous, relevant content generation tailored to precise user needs.

Why Developers Should Embrace RAO Now

Stay Ahead of Search Evolution: Be future-ready for AI-driven platforms.
Improve User Engagement: Deliver timely, personalized content reliably.
Automate Tedious Processes: Reduce manual SEO tweaking and content refreshing.

Conclusion

Traditional SEO tactics centered on static optimization are becoming relics. RAO’s ability to bridge live, context-aware data with AI content generation marks the next big shift in search and discovery. By automating this process through tools like n8n, developers and content creators can build workflows that deliver dynamic, tailored content at scale.

If you’re ready to leave behind outdated techniques and embrace the future of digital discovery, explore RAO-driven automation workflows and see firsthand how dynamic content can elevate your projects.

Explore the workflow I crafted and put RAO into action today: n8n Workflow.

How I automated my blog and doubled traffic

Łukasz Blania — Sun, 24 Aug 2025 14:21:46 +0000

Introduction

Managing a software development blog can quickly become overwhelming. Between content creation, scheduling, social sharing, and optimization, manual handling soon exhausts your time and focus. I faced these very challenges—pain points that limited my ability to grow and engage consistently.

Driven by the need to regain bandwidth and scale effectively, I embarked on automating crucial aspects of my blog operations. With automation, I didn't just get time back; I transformed my whole publishing workflow, enhanced content reach, and saw tangible growth in organic traffic.

Facing the Pain Points

Before automation, my key struggles included:

Manual content scheduling: Copy-pasting and trackboarding post times across platforms.
Social media sharing: Inefficient, repetitive manual announcements leading to inconsistency.
Keyword research: Time-consuming research slowed down content ideation.
Post enhancements: Limited time to refine posts with SEO and readability improvements.

These tasks drained hours weekly and created bottlenecks that impeded steady publishing.

Introducing Automation: The Tech Stack and Workflow

I adopted a layered approach using automation tools and workflow platforms tailored for blogging needs:

1. Automated Content Scheduling & Publishing

Utilizing n8n's Blogging Workflow as my backbone automation, I linked my CMS to a workflow that:

Publishes new blog posts automatically at scheduled times.
Triggers optimized social media sharing seamlessly.

2. RSS-to-Social Workflow

Once a post goes live, an automation grabs the RSS feed, crafts engaging social snippets, and posts them across Twitter and LinkedIn without manual intervention.

3. Automated Keyword Research

Using API integrations with keyword research tools, the workflow periodically suggests high-impact keywords for my niche, feeding new content ideas directly to my editorial calendar.

4. AI-Driven Post Enhancements

To improve quality and SEO, AI tools automatically analyze draft posts for readability metrics and suggest edits, freeing me to focus on core content.

Quantifiable Results

Since embracing these automated workflows, results have been undeniable:

+60% increase in organic traffic within three months.
Consistent publishing cadence, averaging one optimized post weekly.
20% boost in social engagement, driven by timely, automated announcements.
Freed over 8 hours per week from routine tasks.

Automation not only scaled my blog's reach but also improved my productivity and content quality.

Why It Matters for Developers and Content Creators

If you're a technical blogger, indie hacker, or developer juggling content creation with your core projects, automation offers a practical solution to amplify impact without burnout.

The workflows I used are adaptable and built on open, flexible platforms that empower you to create tailored automation matching your style and goals.

Final Thoughts

Automating blog operations redefined how I approach my content ecosystem—from ideation to audience engagement. For anyone serious about growing a blog sustainably and efficiently, integrating automation workflows is a game changer.

You can explore and start using these automations yourself with n8n's Blogging Workflow: ready-to-use automation for blog publication, social sharing, and content optimization.

Take a moment and imagine what automating repetitive tasks could free you up for—more innovation, coding, or just thinking deeply about your next big post.

Happy automating!