Vibe Coder Bootcamp — News & Bookmarks Hub

minicoohei.eth 🏷 学習リソース @minicoohei · 4月13日

タイトル: Claude のManged Agentsに、土日で俺俺ハーネスを移植してみたら、法人向けにはこれだなって感じた話 GitHub Actions + Lightsail + Claude Code の非対話モード（claude -p）で動かしていた AI エージェント群を、Anthropic の Managed Agents API に土日をかけて移行してみた。正直に言うと、移行前はかなりの「俺俺」ソリューションを積み上げていた。外部通信を制限する俺俺ネットワーク制御、API キーを安全に渡す俺俺 CredentialManager、ツール実行を監視する俺俺 EventHooksCheckTool、自律改善のための Loop 機構——全部自前で書いていた。それが全部いらなくなった。ネットワーク制限、Vault による秘密情報管理、Event Stream による全操作の監視——セルフホスト構成で苦労して実現していたセキュリティとオブザーバビリティが、API 一本で手に入る。頑張ってハーネスを作ってきたけれど、Managed Agents で立てるほうが圧倒的に楽だと感じた。ただし、Agent をガンガン動かすとガンガンお金がかかる。これは悩ましいポイントで、実際に GTM（Go-To-Market）キャンペーンの一部は従来の GitHub Actions + 軽量スクリプト構成に戻してコストを抑えている（後述）。コストが許せるなら Managed Agents 一択だが、現実はそうもいかない。一方で、これまで作ってきた 100 以上の Claude Code Skills はそのまま使えた。Managed Agents の Skills API に登録するだけで、各 Agent がドメイン知識として参照できる。ここは無駄にならなかった。この記事は、Environment 作成から Agent 定義、Vault 設定、Slack/LINE Bot の接続、Langfuse による品質モニタリングまで、全フェーズの実装過程をコード付きで記録したビルドログだ。 Managed Agents 1. Managed Agents とは何か Managed Agents は Anthropic が提供する Agent 実行基盤（beta API）だ。従来の messages.create() が1回きりのリクエスト/レスポンスなのに対し、Managed Agents はステートフルなセッションの中で Agent が自律的にツールを使いながらタスクを完了する。 4つの中核概念がある。 Agent モデル + system prompt + tools の束。これが「誰が何をできるか」の定義になる。今回のシステムでは 8 つの Agent を定義した。重要なのは、Agent の定義は再利用可能だということ。一度作れば、何度でもセッションを生成できる。実際の Anthropic Console では、作成した Agent がこのように一覧表示される。 Session ステートフルな会話単位。Agent に紐付けて作成し、メッセージを送信すると Agent が動き始める。全てのやりとりは Event Stream として流れてくる。 Environment sandbox 実行環境。Agent がコードを実行する場所であり、ここでネットワーク制限とパッケージ制御を定義する。 allowed_hosts に含まれないドメインへの通信はブロックされる。これだけで、Agent が意図しない外部サービスにデータを送信するリスクを排除できる。 Vault 秘密情報の安全な受け渡し。API キーやトークンを暗号化して保存し、Agent に安全に渡す仕組み。従来の .env ファイルにベタ書きと違い、Vault 経由なら Agent から直接トークン値を見ることはできない。MCP サーバーの認証に自動で使われるだけだ。 2. Before → After: GitHub Actions + Lightsail vs Managed Agents Before: GitHub Actions + Lightsail + 俺俺ハーネス従来のアーキテクチャはこうだった。 GitHub Actions (cron) → Lightsail (self-hosted runner) → Claude Code CLI (claude -p) が bash/read/write で直接サーバー操作 → .env がサーバー上に平文で存在 → ネットワーク制限なし → エラーリカバリは手動 Claude Code CLI は非常に強力だが、何でもできてしまうのが問題だった。SSH で任意のコマンドを実行でき、.env ファイルを直接読める。ネットワーク制限もないので、理論上は任意の外部サービスにデータを送信できる状態だった。だから「俺俺」ソリューションを積み上げた。俺俺外部通信制御: allowed_hosts リストを CLAUDE.md に書いて、Agent が通信していいドメインを制限。ただし Claude Code はこれを「お願い」として扱うだけで、技術的に強制はできない俺俺 CredentialManager: .env の値を直接読ませず ${VAR} で間接参照させるルール。これも CLAUDE.md でのお願いベース俺俺 EventHooksCheckTool: Claude Code の hook 機能でツール呼び出し前に安全性チェック。しかし hook の仕様変更で壊れることがあった俺俺 Loop 機構: Agent が自律的に改善サイクルを回す仕組み。GitHub Actions の dispatch event でループを実現どれも「やらないでね」というプロンプトベースの制約か、壊れやすいラッパーだった。機能はしていたが、安心感はなかった。 After: Managed Agents SessionLauncher → Anthropic Cloud (sandbox) → Agent がsandbox 内で実行 → Vault で秘密情報を暗号化管理 → allowed_hosts で16ドメインのみ通信許可 → Event Stream で全操作をリアルタイム監視 → Permission Policy でツールごとにallow/ask制御変わったのは主に3点。 1. ネットワーク制限 allowed_hosts で明示的に許可したドメインのみ通信可能。今回は 16 ドメインに絞った。 2. Vault による秘密情報管理 .env から Vault に移行。Agent は MCP サーバーの認証に Vault を使うが、トークン値そのものにはアクセスできない。 3. Event Stream による全操作の監視 Agent の全ツール呼び出し、全出力がリアルタイムで Event Stream に流れる。何をやっているか常に見える。 3. Agent の登録方法 — 3ステップで動かす Step 1: Environment 作成 create_environment.py は冪等。同名の Environment が存在すれば ID を返すだけ。 Console 上ではこう見える。 production Environment が Active で、Type は Cloud だ。 Step 2: Vault + Credential 設定 Credential の種類は 2つ。 static_bearer: API キー・トークン（Linear, GitHub, Slack, Resend, Datadog, OpenAI） Environment Secrets: AWS credentials（boto3 が自動で読むため） Google OAuth だけは Console から手動設定が必要。 Credential Vaults の画面。managed-agents-secrets に全 Credential が格納されている。 Step 3: Agent 定義 --create フラグなしでは dry-run。全 Agent が冪等に作成される（同名が存在すれば skip）。各 Agent の tools 構成: permission_policy で各ツールの許可レベルを制御。always_allow は自動承認、always_ask はオペレーター確認が必要。GitHub の create_issue や create_pull_request は always_ask にしてある。 4. Custom Tool の設計 Managed Agents には組み込みツール（bash, read, write 等）があるが、Linear や S3 など外部サービスとの連携には Custom Tool が必要になる 4種類の Custom Tool ルーティングパターン Agent が Custom Tool を呼ぶと agent.custom_tool_use イベントが発火する。SessionLauncher がこれを受け取り、tool_name の prefix でハンドラに振り分ける。 delegate_to_agent — Agent 間委譲これが最も重要な Custom Tool だ。SDK には callable_agents パラメータが存在しないため、Agent 間の委譲は Custom Tool で自前実装する必要がある。仕組みはシンプル。 Orchestrator が delegate_to_agent({agent_name: "Task Executor", message: "..."}) を呼ぶハンドラが SessionLauncher.create_session() でサブセッションを生成 stream_until_idle() でサブセッションの Event Stream を全消費結果テキストを custom_tool_result として Orchestrator に返す Orchestrator から見ると、あたかも普通のツール呼び出しのように見える。実際には裏でサブセッション全体が動いている。以下がその具体的な処理フローだ。 5. セッション管理と Event Stream 以下が SessionLauncher の実際のシーケンスだ。create_session() でセッションを作り、stream_until_idle() で Event を消費しながら Custom Tool をブリッジする全体像がわかる。 SessionLauncher がこのシステムの心臓部だ。セッション作成 → イベント購読 → Custom Tool ブリッジを一手に引き受ける。 Console の Sessions 画面では、全セッションの履歴が一覧表示される。どの Agent がいつ実行され、何分で完了したかが一目でわかる。 stream_until_idle() のイベントループ copy stop_reason の分岐が最も重要なポイント。 end_turn: Agent がタスク完了と判断。break。 requires_action: Custom Tool の結果待ち。break してはいけない。custom_tool_result 送信後もストリームを継続する。 retries_exhausted: リトライ上限到達。break。 requires_action で break すると Agent がハングする。これは実際にハマったバグだ。 6. 品質管理 — Review Agent と Outcome Rubrics Agent の出力は必ずしも正しくない。「ファイルを S3 にアップロードした」と言っても、実際にはアップロードが失敗している可能性がある。 S3 実検証 Review Agent は「成果物を作った」という Agent の自己申告を信用しない。実際に S3 からダウンロードして中身を確認する。 Outcome Rubrics 5段階スコアリングで品質を定量評価する。 pass_threshold: 3.5（平均以上で合格） hard_fail: correctness または compliance が 2 以下で即不合格 7. Observability — Datadog + Langfuse なぜ 2つ必要か。Datadog はインフラ監視 + アラート、Langfuse は LLM 特化の eval + コスト追跡。役割が違う。 Datadog LLM Observability agentless_enabled=True で LLM Observability データを Datadog API に直送する。ただし ddtrace をインポートすると APM Tracer と AppSec パッチが自動で有効になり、ローカルの Datadog Agent (localhost:8126) への接続を試みてエラーログが大量に出る。DD_TRACE_ENABLED=false で APM を止め、LLM Obs だけを動かすのが正しい構成。 LLM-as-a-Judge 自動評価 Langfuse の LLM-as-a-Judge 機能で、Agent の出力品質を自動評価する Evaluator を 4つ設定した。 Hallucination: 出力に幻覚が含まれていないか Goal Accuracy: タスクの目標を達成しているか Faithfulness: 入力データに忠実か Context Recall: 必要なコンテキストを参照しているかすべて observation ベースの Evaluator で、claude-sonnet-4-5 がジャッジする。 Quality Scores ダッシュボードダッシュボードでスコアの推移と Tool 利用頻度を一覧できる。cron 実行のたびにデータが蓄積される。 Review Agent スコアの自動送信 Langfuse にスコアを記録するため、delegate_tools.py で Review Agent の JSON 出力を自動パースして log_scores() を呼ぶ仕組みを入れた。 Orchestrator が Review Agent にタスクを委譲するたびに、correctness, communication, efficiency, rubric_passed が Langfuse に自動記録される。ダッシュボードで品質推移を追跡できる。 8. Interface Layer — リアルタイム対話 Agent と人間の接点は 4つ。以下がSlackメッセージからAgent実行、スレッド返信までの全体フローだ。 Slack Socket Mode 4つの Slack ワークスペース（tokenpocket, infobox, yoake, fungiblex）を同時に監視する。なぜ Events API ではなく Socket Mode か？ Lightsail が Tailscale 内にあり公開 URL がないため、WebSocket 接続で Slack 側からのプッシュを受け取る。 app_mention（メンション）と message.im（DM）の両方をハンドルする。 LINE Bot Tailscale Funnel で公開 HTTPS URL を提供し、LINE の Webhook を受ける。 Linear ISSUE管理をLienarにして、LinearにそのままコメントしたらAgentが処理をするようにした。 SessionManager Slack/LINE からのメッセージを Managed Agent セッションに紐付けるインメモリキャッシュ。 TTL は 4時間。同じスレッド内の連続メッセージは同じセッションに送られる。最初のバージョンではフォローアップメッセージが既存セッションに送信されないバグがあった（Codex レビューで発見）。events.send() の追加で修正。 Cron 通知 KB Agent と Orchestrator の定期実行後、NotificationSender が Slack（#agent-notifications）と LINE に結果を通知する。 9. Skills 統合 — 旧リポから37スキルを移行 Phase E で、旧リポジトリ（githubactions_fordata）の 104 スキルを精査し、37 の Custom Skill として Managed Agents に移行した。 Skills とは Managed Agents の Skills は、Agent にドメイン知識を与える仕組みだ。Tools が「何ができるか」なら、Skills は「どうやるか」のノウハウに相当する。各スキルは SKILL.md（マークダウン）で記述し、API でアップロードして Agent に紐付ける。 104 → 37 への精査旧リポには 104 のスキルがあったが、重複・廃止・Managed Agents 非互換を除外して 37 に絞った。 Agent 別のスキル配分上限は Agent あたり 20 スキル。GTM Writer が 15/20 で最も多い。 migrate_skills.py — アップロードの仕組みアップロード後、create_agents.py --update で各 Agent にスキルを紐付ける。 Custom Skills（自前の SKILL.md）と Official Skills（Anthropic 公式の pptx, xlsx, pdf 等）の2種類がある。 10. コスト最適化 — 全部を Agent にしない判断 Managed Agents は強力だが、使えば使うほどコストがかかる。Opus モデルで Agent を回すと 1 セッションあたり数ドル〜十数ドル。cron で毎日回せば月額はすぐに膨らむ。実際に運用してみて、「全タスクを Managed Agents に載せるべきではない」という判断に至った。 GTM キャンペーンはスクリプトに戻した GTM（Go-To-Market）キャンペーン——SEO 記事の生成、SNS 投稿、動画スクリプト作成、B2B アウトリーチ——は、当初 Managed Agents の GTM Writer / GTM Video / GTM Outreach に載せる予定だった。だが実際には、GTM タスクの大半は「定型的な処理の繰り返し」だ。9 つの戦略レンズ（Content, Quality, Trends, Distribution, Campaigns, Analysis, Infrastructure, B2B Outreach, Development）に基づいて Issue を自動生成し、1 つずつ実行する。これを Managed Agents で回すと: 1 Issue あたり Opus セッション 1 回 = 数ドル 1 日 5〜10 Issue = $15〜50/日月額 = $450〜1,500 同じことを GitHub Actions + Claude Code CLI（claude -p）+ 軽量スクリプトでやると: Claude Max プラン $200/月（定額）で回せる scripts/gtm/ に 25 本の特化スクリプトを置いて、gtm-manager.yml（6 時間ごと）と gtm-patrol.yml（毎時）で実行コスト可視化スクリプト（gtm_cost_tracker.sh）で API 等価コストを追跡【コスト (API等価)】今日: $45.23 / 7日間: $312.50 累計: $11,011.72 (ROI 55.1x) 定額プラン: $200/月 API 等価で月 $1,000 以上の処理を、定額 $200 で回せている計算。ROI 55 倍。判断基準: Managed Agents vs スクリプト結果として、8 Agent のうち実際に cron で毎日動かしているのは KB Agent と Orchestrator の 2 つ。残りは Slack/LINE からのオンデマンド実行か、Orchestrator からの委譲時のみ動く。GTM 系タスクは引き続き GitHub Actions + スクリプト構成で、コストを月 $200 に抑えている。 Lightsail の self-hosted runner を残した理由 Managed Agents に移行したのに、なぜ GitHub Actions + Lightsail を完全に捨てなかったのか。理由は Vault が MCP サーバーの認証にしか使えないからだ。 Vault に登録した Credential は MCP サーバー（GitHub 等）の認証に自動で使われる。しかし、それ以外の用途——たとえば Google Drive にファイルをアップロードする、YouTube に動画を投稿する、Slack の複数ワークスペースに投稿する——には Custom Tool 経由で自前のコードを動かす必要がある。Custom Tool のハンドラは Anthropic Cloud 内ではなく、こちら側のプロセスで動く。つまり結局、API キーや OAuth トークンを持ったサーバーが必要になる。それなら、Claude Code CLI（claude -p）で直接サーバーを触れたほうが楽な場面も多い。ファイルシステムに直接アクセスできるし、gcloud、aws、ffmpeg も直接叩ける。Managed Agents の sandbox 内ではパッケージを allowed_packages に追加する必要があるし、ネットワーク制限で通信先も明示的に許可しないといけない。だから現実的な構成はこうなった。セキュリティ重要 + 複雑なタスク → Managed Agents（Vault + ネットワーク制限 + Event Stream）定型タスク + 外部サービス直叩き → GitHub Actions + Lightsail + Claude Code CLI（コスト最適化 + 柔軟性）全部を Managed Agents に載せるのが理想だが、現時点では Custom Tool のハンドラをどこかで動かす必要がある以上、self-hosted runner は残しておくのが現実解じゃないかと思った。（セキュリティ的に鍵を触れない部分はIFで防がれてるのでかわらないので。） Skills は両方で使えるここが嬉しいポイントだった。Claude Code の Skills（.claude/skills/ に置いた SKILL.md）は、Managed Agents にも GitHub Actions にもそのまま使える。 Managed Agents: Skills API でアップロードして Agent に紐付け GitHub Actions: Claude Code CLI が .claude/skills/ を自動で読み込み 100 以上のスキルを作ってきた投資が、どちらの構成でも活きる。移行で無駄になったものは「俺俺ハーネス」だけで、コンテンツ資産は全部残った。 12. まとめ -Managed Agentsすごい。全フェーズの概要率直な所感正直、頑張って俺俺ハーネスを作ってきたけど、Managed Agents で立てるほうが良いと感じた。コストが許せるのであれば。俺俺外部通信制御、俺俺 CredentialManager、俺俺 EventHooksCheckTool——どれもプロンプトベースの「お願い」か、壊れやすいラッパーだった。 Managed Agents なら allowed_hosts で通信先を技術的に強制でき、Vault で秘密情報を暗号化管理でき、Event Stream で全操作がリアルタイムで見える。「お願い」から「強制」に変わる。これは大きい。一方で、全部を Agent に載せるとコストが爆発する。GTM キャンペーンのように定型的なタスクは、GitHub Actions + 軽量スクリプト + Claude Max 定額プランで回すほうが圧倒的にコスパが良い。使い分けが重要だ。これまで作ってきた 100 以上の Claude Code Skills はそのまま使えた。Managed Agents にも GitHub Actions にも登録できる。コンテンツ資産は無駄にならなかった。移行で捨てたのは「俺俺ハーネス」だけだ。 Managed Agents API の良い点ネットワーク制限と Vault だけでセキュリティが劇的に改善 Event Stream で Agent の全操作がリアルタイムで見える Environment のパッケージ管理でサーバーのセットアップ不要冪等な API 設計（同名リソースの作成は skip） Skills API で既存のナレッジ資産をそのまま移行可能改善希望 callable_agents パラメータがほしい（Agent 間委譲を公式サポート）複数アカウント触れるMCPが欲しい（GoogleもSlackもNotionも） Vault の OAuth フローがもう少し簡単になるとありがたい Langfuse でモニタリング体制を整えるべし Managed Agents のコスト管理には Observability が不可欠だ。Langfuse で全セッションのトレース、ツール呼び出し、Review Agent のスコアを自動記録している。LLM-as-a-Judge で品質を定量評価し、コスト対効果を常に追跡できる体制にした。「Agent をガンガン動かしてガンガンお金がかかる」状態を、データで制御する。使い分けの結論

Ronin 🎨 デザイン @DeRonin_ · 4月13日

タイトル: How to become an AI Automation Builder in 6 months (RESOURCES) AI automation has quietly become the highest-ROI skill in the entire AI space right now The problem is that most people entering this field get stuck the same way Some open a Python tutorial on day one, hit a wall in week two, and never touch a no-code tool Some get lost in 8-hour YouTube tutorials without ever building a single workflow for a real business Others jump straight into "AI agents" without understanding how a basic workflow or an API actually works The result is always the same: a folder of half-finished demos and zero paying clients Here's the truth almost nobody tells beginners: "You don't need to become a software developer to become an AI Automation Builder!!!" "You don't need to learn machine learning" "You don't need to fine-tune a model" You need to learn how to connect AI to the tools companies ALREADY use and automate the boring, repetitive work they are currently paying humans to do That means learning how to: build end-to-end automated workflows across real business tools wire AI into CRMs, email, docs, and support systems turn repetitive human tasks into reliable AI-powered pipelines ship automations that survive real client traffic charge $500-5k/mo and deliver measurable ROI This guide was created to give you a practical 6-month roadmap The article is 10,000+ WORDS, so reading it may take a few hours But its real value is that for every skill you need to learn, there are resources and clear explanations of what to do next That way, within six months you can reach the level of a hireable AI Automation Builder, and start earning from it already within the first 1-2 months [ Now let's start reading the article ] ⬇️ Read this first: non-technical path vs developer path This roadmap works for two different kinds of people, and you need to pick which one you are BEFORE you start Non-technical path (DEFAULT — most of you are here) You have never coded, or you know a little but you don't want to become a developer. Your superpower is going to be no-code tools (n8n specifically), connected to AI through simple nodes. You can build and sell real automations without ever writing a line of Python if you don't want to. This is the fastest, most realistic path to your first paying client Developer path (OPTIONAL add-on) You already code, or you really want to learn. You will follow the same roadmap but ALSO pick up Python, LangGraph, and custom backend pieces. This unlocks bigger contracts and more complex work later, but it is completely optional Every month below is written for the non-technical path first. At the end of each section, there's an optional "developer path" box with the extra stuff to learn if you want to go that direction. Skip it without guilt if you don't One rule: pick a lane and stop switching. People who bounce between "I'll learn no-code" and "I'll learn Python" for 6 months end up with neither What an AI Automation Builder actually does? A lot of people hear "AI automation" and imagine shiny AI agents that replace entire teams In reality, most of the work is much more boring and much more profitable You take expensive, repetitive business processes and rebuild them as AI-powered workflows that run 24/7 without humans babysitting them That usually includes: connecting LLMs to tools companies already use (CRMs, email, Slack, Notion, databases) turning triggers from one system into actions in another adding AI decision-making into previously manual workflows replacing human triage, classification, and routing work with LLM calls building internal knowledge bots over company docs automating lead generation, outreach, content, and support pipelines monitoring and handing these systems off to non-technical clients So in practice, an AI Automation Builder sits somewhere between: workflow automation (n8n, Make, Zapier) applied AI (LLMs, prompts, simple agents) business process consulting (knowing what's actually worth automating) light technical glue work (reading docs, fixing small things, debugging) This is why the role is exploding right now Every SMB, agency, and SaaS company in 2026 has 20 repetitive workflows they are paying humans too much to run They don't need researchers. They don't need fine-tuners. They need someone who can walk in, find the bleeding, and stop it with a workflow that pays for itself in the first month That's also why this roadmap focuses less on building products and more on shipping business outcomes If you can wire AI into a real CRM, a real inbox, and a real content pipeline, you're already more employable than 90% of people calling themselves "AI engineers" on LinkedIn Also, until we started, let me give to you a little motivation to learn it: Still 310M companies which haven't applied and added any kind of automation!!! Into the world, here's in general 360M (only 50M companies added partial automation to their business processes) And THE MOST IMPORTANT THING, in total ONLY 1M people into the world might provide this service on decent level Lol, 8B+ ppl live on this planet, THAT'S ABSOLUTELY NOTHING. WE'RE SO EARLY!!! Also, catch potential rates which you can appoint to any of these automations: - $500-5k/mo to build automated workflows for businesses - $1-3k/mo to automate lead generation systems - $500-2k/mo for AI-powered content pipelines - $1-4k/mo to automate customer support with AI agents - $500-2k/mo for automated reporting & data dashboards - $500-2k/mo for AI-powered cold outreach systems - $1-3k/mo to set up internal automation assistants - $500-1.5k for AI workflow training for teams - $300-1k for 1:1 automation consulting *It's average prices which I could find across different freelance and outsource platforms + my frens who are doing it professionally shared with me That means they can be much higher (depends on the company size and how many employees they would love to fire lol) LET'S BEGIN!!! ⏩--------------------------------------------------------------------⏪ Month 1: Build your first workflow in n8n Your goal this month: Build your first real automation in n8n, understand how APIs and webhooks work at a conceptual level, and learn enough about prompting to make an LLM do what you want You are NOT learning Python this month (unless you're on the developer path). You're learning the one tool that is going to pay your bills for the next 6 months, and the vocabulary you need to read docs without panicking What to learn: 1. Pick ONE no-code platform and go deep (start HERE) This is the most important decision of Month 1. Pick ONE tool. Go deep. You can learn the others later in a weekend once you understand the underlying concepts Which one to pick: n8n: pick this if you're serious about this career. Open-source, generous free tier, best-in-class AI nodes, self-hostable, and the automation agencies making real money are all here. This is the default recommendation for this entire roadmap Make (formerly Integromat): pick this if you want the prettiest visual interface. Great for agency client work and complex branching Zapier: pick this ONLY if you're building quick MVPs for non-technical clients who already use it. Too expensive at scale for serious work My recommendation: go with n8n. Everything in this article assumes n8n unless stated otherwise Resources: 1. n8n Official Docs (free) Link: https://docs.n8n.io/ Start with "Quickstart" and work through every core concept. The docs are genuinely excellent 2. n8n Academy (free) Link: https://docs.n8n.io/courses/ Official free courses covering beginner to advanced workflow patterns, including AI integration. This is the single best resource in the entire 1st month 3. Productive Dude (YouTube, free) Link: https://www.youtube.com/@productivedude n8n-focused, extremely practical, beginner-friendly videos 4. Nick Saraev (YouTube, free) Link: https://www.youtube.com/@nicksaraev Focused specifically on making money with automation. High signal 5. Make Academy (free, if you picked Make) Link: https://academy.make.com/ What to focus on: Triggers (cron, webhook, app events) vs actions How data moves from one step to the next Error handling and fallback paths Using the HTTP Request node when there's no native integration Reading and debugging execution logs The built-in OpenAI and AI Agent nodes (you'll use these in Month 2) Practice: Automate something in your own life. Seriously. Auto-save email attachments to Google Drive. Scrape a product price daily into a Google Sheet. Send yourself a Telegram message when a specific keyword appears in your inbox. Build the muscle with low stakes before you build for clients 2. APIs, webhooks, and JSON (the vocabulary, not the code) Every automation you ever build connects two systems through APIs. You don't need to CODE APIs. You need to UNDERSTAND them enough to read a doc, know what a webhook is, and know what JSON looks like when you stare at it Resources: 1. What is a Webhook? (Zapier blog, free) Link: https://zapier.com/blog/what-are-webhooks/ The best beginner explanation of webhooks, written for non-developers 2. HTTP basics — MDN Web Docs (free) Link: https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview Clearest free explanation of how the web talks to itself 3. Postman Learning Center (free) Link: https://learning.postman.com/ Postman is the universal tool for testing APIs. Go through "Getting Started" before touching any real API. You click buttons. No code 4. REST API Tutorial (free) Link: https://restfulapi.net/ Short, practical, no unnecessary theory What to focus on: GET vs POST vs PUT vs DELETE (what each is used for) What JSON looks like (curly braces, key-value pairs, arrays) HTTP status codes: 200 (good), 401 (bad auth), 404 (not found), 429 (rate limited), 500 (broken) API keys and bearer tokens at a conceptual level (you paste them, you don't build them) Webhooks vs polling (when to use each) Rate limits and what happens when you hit them Practice: Use Postman to call a free public API (try https://api.github.com/users/torvalds). See the JSON come back. Now recreate the exact same call inside an n8n HTTP Request node. Compare. This one exercise unlocks 50% of the mystery of APIs for non-technical people 3. Reading API docs without panicking Every real automation eventually requires reading an API doc. This is the skill that separates people who ship from people who wait forever for a YouTube tutorial that covers their exact use case (spoiler: it doesn't exist) Resources: 1. How to Read API Documentation — Postman Blog (free) Link: https://blog.postman.com/how-to-read-api-documentation/ Short, practical breakdown of how API docs are structured 2. Stripe API Docs (free, best-in-class example) Link: https://docs.stripe.com/api Study this even if you never use Stripe. It's the gold standard for API documentation design What to focus on: Finding the "Authentication" section first, always Identifying the base URL, endpoint paths, methods, required parameters Reading request/response examples Spotting rate limits and pagination patterns Testing one endpoint in Postman before wiring it into a workflow Practice: Pick any tool you already use (Notion, Airtable, Slack, HubSpot) and make ONE successful API call from Postman. Just one. Pull a list of something. Then stop 4. Basic prompt engineering You don't need to become a prompt wizard. You need to understand the fundamentals: system vs user prompts, specificity, examples, and how to force structured output so the rest of your workflow can use it Resources: 1. Anthropic's Interactive Prompt Engineering Tutorial (free, GitHub) Link: https://github.com/anthropics/prompt-eng-interactive-tutorial The best hands-on intro to prompting, broken into chapters with exercises 2. OpenAI Prompt Engineering Guide (free) Link: https://platform.openai.com/docs/guides/prompt-engineering 3. Learn Prompting (free, comprehensive) Link: https://learnprompting.org/ A full free course from basics to advanced 4. Advanced Prompt Engineering Article from @EXM7777 (free) Link: https://x.com/EXM7777/status/2011800604709175808 What to focus on: System prompts vs user prompts Why specificity beats cleverness Giving examples (few-shot prompting) Asking for structured output (JSON, CSV, specific formats), this is what makes AI usable inside automations Chain-of-thought for tasks that require reasoning 5. What LLMs are actually good at (and where they fail) This one saves you from embarrassing yourself in front of a client. Knowing when NOT to use AI is just as valuable as knowing when to use it Resources: 1. Andrej Karpathy YouTube talks (free) Link: https://www.youtube.com/@AndrejKarpathy Clearest thinking on where LLMs add real value 2. Simon Willison's Blog (free) Link: https://simonwillison.net/ The most practical voice in applied AI. Read his recent posts What to memorize: Good at: classification, summarization, extraction, translation, drafting, decision trees with clear criteria Bad at: exact math, real-time data without retrieval, tasks requiring perfect consistency, anything safety-critical 6. (Developer path only) Just enough Python to unblock yourself Skip this section if you're on the non-technical path If you want the dev path, learn just enough Python to read docs, write small scripts, and glue things together when a no-code tool hits a wall. Not to become a senior dev Resources: 1. Python for Everybody (Coursera, free to audit) Link: https://www.coursera.org/specializations/python 2. freeCodeCamp Python Course (YouTube, free) Link: https://www.youtube.com/watch?v=rfscVS0vtbw 3. Automate the Boring Stuff with Python (free online book) Link: https://automatetheboringstuff.com/ Specifically for people who want to automate tasks, not build apps What to focus on: variables, loops, conditionals, functions, lists, dicts, JSON, reading files, requests library, try/except, running scripts from terminal Month 1 Milestone: By the end of this month you should be able to: Build a 3-5 step workflow in n8n that solves a real problem in YOUR own life Explain what webhooks, API keys, JSON, and HTTP status codes are (in plain English) Read an unfamiliar API doc and successfully make a test call with Postman Write a clear system prompt that returns consistent structured output List 5 tasks LLMs are good at and 5 where they'll embarrass you If you hit all of these, you're already ahead of 80% of people trying to "break into AI" right now ⏩--------------------------------------------------------------------⏪ Month 2: Embed AI into your workflows Your goal this month: Stop using ChatGPT manually. Start making AI run automatically inside your n8n workflows, reacting to real triggers, making decisions, and writing to real systems (without you pressing a button) By the end of Month 2 you should have 3-5 real workflows that use AI inside them, and you should already have a clear idea of what your FIRST paid gig will look like This is the month where you stop being a no-code user and start being an AI Automation Builder What to learn: 1. n8n's AI nodes (the default path) n8n has built-in nodes for OpenAI, Anthropic, and a full AI Agent node. For 90% of what you'll ever need to ship, you don't need to touch Python at all. You drop an AI node into your workflow like any other step Resources: 1. n8n AI Nodes & LangChain Docs (official, free) Link: https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/ Walk through the full AI section of their docs. The n8n team has done an insane amount of work making AI usable from a no-code canvas 2. n8n Academy: AI Workflows Course (free) Link: https://docs.n8n.io/courses/ There's a dedicated AI track. Do it 3. n8n AI Templates (free) Link: https://n8n.io/workflows/?categories=AI 100+ real, importable templates. Better than any tutorial (import one, run it, see exactly how it's wired) What to focus on: Dropping an OpenAI or Anthropic node into a workflow Passing data FROM a previous step INTO the prompt dynamically (expressions in n8n) Parsing the AI response and using specific fields in later steps Keeping your prompts in a central place (a Notion doc or a dedicated n8n sub-workflow) so you can edit them without digging When to use AI inline vs when a simple IF node is enough Practice project: Build a workflow that watches a Google Form, sends new responses to an LLM for classification (urgent / normal / spam), and writes the classified response into different Airtable tables based on the category. No code. Pure n8n 2. The core skeleton: Trigger → AI Decision → Action → Output Almost every AI automation you will ever build fits this skeleton: Trigger (something happens) → AI decision (classify, extract, generate) → Action (write to a system) → Output (notify / log / confirm) Master this one skeleton and you can already build 80% of real-world automations without ever touching an "agent" Resources: 1. Anthropic: Building Effective Agents (free) Link: https://www.anthropic.com/research/building-effective-agents Read the "Workflow patterns" section. Covers prompt chaining, routing, and parallelization with clear diagrams. Ignore the agent-framework stuff for now 2. n8n AI Templates (free) Link: https://n8n.io/workflows/?categories=AI Pick 3 templates that match this skeleton and dissect them What to focus on: Sketching the workflow on paper BEFORE you drag a single node One LLM call per decision (don't try to make one giant prompt that does everything) Idempotency (running the same workflow twice shouldn't double-process) Where to use an IF node (deterministic) vs an AI node (fuzzy) Practice project: Build a workflow that reads incoming emails (Gmail trigger), uses AI to classify into {support, sales, personal, spam}, and routes each category to a different action. Create a ticket, create a CRM lead, forward, or archive. No agents. Just a clean chain 3. Error handling and fallback logic (the "clients will actually pay you" part) Your workflows will fail in production. APIs go down. Rate limits get hit. The LLM returns malformed JSON. Clients don't pay you to build things that work 90% of the time. They pay you for things that work 99.9% and gracefully handle the other 0.1% Resources: 1. n8n: Error Handling & Error Workflows (free) Link: https://docs.n8n.io/flow-logic/error-handling/ How to build a global error handler that catches any failure in any workflow. This is n8n's single best feature for production 2. n8n: Retry on Fail (free, same page) Built into every node. Learn it early 3. Nate Herk: Workflow for Unlimited Error Handling (free) Link: https://www.youtube.com/watch?v=bTF3tACqPRU He has literally explained 95% of potential errors and failures which might appear What to focus on: Enabling "Retry On Fail" on every API-calling node Building one central error workflow that catches failures from all your other workflows Re-prompting the LLM when it returns malformed JSON Notifying yourself in Slack or Telegram when a critical workflow breaks Fallback logic: if the primary model is down, try a secondary one 4. Cost awareness: tokens, pricing, and when AI is overkill Shipping AI automations without understanding token costs is how you end up with a $3,000 surprise bill on a client project. This skill pays for itself in the first month. VERY IMPORTANT (I lost $400 because of it) Resources: 1. OpenAI Pricing (free) Link: https://openai.com/api/pricing 2. Anthropic Pricing (free) Link: https://www.anthropic.com/pricing 3. OpenAI Tokenizer (interactive, free) Link: https://platform.openai.com/tokenizer Paste any text, see exactly how many tokens it is. Use it constantly What to memorize: Input tokens are cheap, output tokens are expensive (usually 4-5x more) Cheap models are "good enough" for classification, routing, and extraction Use expensive models only for creative generation and complex reasoning Calculate the monthly cost of a workflow BEFORE you ship it to a client Practice: Calculate the monthly cost of a workflow that processes 1,000 emails/day, where each email takes 1 classification call on a cheap model and 1 draft generation on a mid-tier model. Get comfortable doing this math (it's what clients trust you for) 5. (Developer path only) Calling OpenAI and Anthropic from Python Skip this if you're on the non-technical track If you want the dev track, learn how to make the same LLM calls from Python that you already make from n8n. This becomes useful when you need to do something n8n can't or when a client wants a fully custom backend Resources: 1. OpenAI API Quickstart (official, free) Link: https://platform.openai.com/docs/quickstart 2. Anthropic API Quickstart (official, free) Link: https://docs.anthropic.com/en/docs/get-started 3. OpenAI Cookbook (official, free) Link: https://cookbook.openai.com/ Runnable notebooks for every common pattern What to focus on: API keys in env vars (never in code), chat completions, system vs user prompts, temperature=0 for automations, model selection, function / tool calling Month 2 Milestone: By the end of this month you should be able to: Drop AI into any n8n workflow with confidence Design a clean trigger → AI → action → output chain for any common business task Handle API failures, bad JSON, and rate limits without your workflow crashing Estimate the monthly cost of any AI workflow before deploying it Point at one of your workflows and say "a business would pay me to set this up for them" and mean it ⏩--------------------------------------------------------------------⏪ EARLY MONETIZATION: Your first $500 gig (Month 2-3) This is the section missing from every "become an AI X in 6 months" article on the internet Most guides send you to freelance work in Month 6. That's way too late. You can and SHOULD start earning in Month 2 or Month 3, the second you have ONE solid workflow you can replicate You don't need a portfolio of 10 case studies to get your first gig. You need ONE working workflow, a 3-minute Loom walkthrough, and the willingness to be awkward in sales conversations for about 2 weeks Where to find your first paying client: 1. Upwork (fastest, best for beginners) Link: https://www.upwork.com/ Create a profile specifically called "AI Automation Builder" or "n8n Automation Specialist." Apply to jobs tagged "Zapier," "Make," "n8n," "automation," "AI workflow." Price yourself at $30-50/hour for the first 2-3 jobs. Don't argue the rate, just build reviews 2. Fiverr (productized offers) Link: https://www.fiverr.com/ Create 2-3 fixed-price offers like "I will build you an AI lead qualification workflow in n8n for $200." Fiverr rewards specificity. Hide the word "AI automation" in your tags everywhere 3. Contra (better rates, less competition) Link: https://contra.com/ Contra is freelance without the race-to-the-bottom pricing. Good for $500-2,000 projects 4. n8n Template Marketplace (inbound leads for free) Link: https://n8n.io/creators/ Publish a free template in the n8n community. People who import it will DM you asking for help customizing. This is the cheapest lead-gen channel in the entire space 5. Your own X and LinkedIn Post EVERY workflow you build. Screenshot the canvas, record a 2-min Loom, write a short caption about the problem it solves. By Month 3 you'll have inbound DMs. I promise What to sell for your first gig: Don't sell "automation consulting." Don't sell "AI strategy." Don't sell hours. Sell ONE of these: Lead qualification bot: $300-500. Form submissions → AI scores them against an ICP → high-score leads get routed to a CRM or Slack channel Email triage assistant: $300-500. Incoming emails get classified by AI, auto-replied to, or routed to the right person Meeting notes to CRM: $400-700. Meeting transcript → AI extracts action items and CRM field updates → writes to HubSpot automatically Content repurposer: $250-400. One long-form post → AI generates variants for X, LinkedIn, and a newsletter → posts draft to Notion for approval All four of these can be built in n8n in a weekend. All four are things businesses will happily pay for What to deliver with every gig (this is what gets you 5-star reviews) The n8n workflow itself (exported as JSON so they can import it) A 3-5 minute Loom walkthrough explaining how it works A one-page Notion doc with: what it does, how to monitor it, what to do if it breaks 7 days of free support after handoff Do all four of those and you will get 5-star reviews from people who have never worked with an automation builder before. That social proof is what unlocks the $1,000+ jobs in Months 4-5 The mental rule Take the gig BEFORE you feel ready. Every single one of my friends making real money in this space took their first gig while they still felt like a fraud. The only way out is through one conversation at a time ⏩--------------------------------------------------------------------⏪ Month 3: Build 1-2 repeatable service workflows Your goal this month: Build 1-2 polished, repeatable automations that solve a real business problem and that you can resell to multiple clients with light customization Important warning: do NOT try to build all 6 use cases in this list in one month. That's how beginners burn out. Pick 1-2 and go deep. You only need ONE sellable service to start earning, and two to have real leverage By the end of this month you should have 1-2 workflows that you can demo in 3 minutes and price on a sales page How to pick your 1-2 use cases??? Ask yourself: Which one sounds the most interesting? (You'll put more effort in) Which one do I already understand the business context for? Which one do I have free access to the tools for? Which one is the most in-demand on Upwork right now? (Search and see what people are posting) Pick based on those. Don't overthink it. Below are the 6 most in-demand use cases in the space, you'll pick 1-2 NOW and come back for the rest later Use case 1: Lead generation automation (highest demand) Lead gen is the #1 most requested AI automation in 2026. Every B2B company wants more qualified leads and fewer SDRs Resources: 1. Apify (free tier) Link: https://apify.com/ Best platform for scrapers. Thousands of pre-built actors for LinkedIn, Google Maps, Crunchbase 2. Clay (paid, free trial) Link: https://www.clay.com/ The industry-standard enrichment platform. Learn it, clients will ask 3. Apollo.io API (free tier) Link: https://docs.apollo.io/ 4. Hunter.io API (free tier) Link: https://hunter.io/api-documentation Email finding and verification 5. Phantombuster (paid, free trial) Link: https://phantombuster.com/ Pre-built scrapers for LinkedIn, Twitter, Instagram Build this one workflow: A pipeline that takes a list of company domains → scrapes website + LinkedIn → enriches with contact info → uses AI to score each against an ICP you define → writes top-scoring leads to a CRM or Google Sheet. Sellable as "Lead Qualification Pipeline — $1,500 one-time + $500/mo" OR, you can don't even build this, since I've already did it instead of you Currently, I am building my own product which calls "Close AI". We specializes on building of our own AI SDR (leads generation automation solution for any request) And we're actively onboarding affiliates to our team who could redirect clients and earn up to 40% per deal (and we already replaced 40 employees in one huge digital company) We made it on the next level and wrote our own LLM model which is studied on huge datasets of a lot of BD chats, Sales calls etc. If you're interested to get a solution which nobody has on the market and sell it: Fill out this Whitelist Form: https://forms.gle/Pj4uSHCNzWLKprzUA Use case 2: AI-powered cold outreach This is where AI automation really shines. Generic cold emails are dead. Clients now expect personalized outreach at 1,000+ contacts/week and only automation makes that possible Resources: 1. Instantly.ai (paid, free trial) Link: https://instantly.ai/ One of the most popular cold email platforms, full API 2. Smartlead.ai (paid, free trial) Link: https://smartlead.ai/ Direct competitor with similar API 3. Lemlist API (paid, free trial) Link: https://developer.lemlist.com/ 4. Clay's Cold Email Playbooks (free blog) Link: https://www.clay.com/learn Build this one workflow: A lead enters from an Airtable view → n8n pulls their 3 recent LinkedIn posts + company website → an LLM writes a genuinely personalized opener referencing specifics → Instantly or Smartlead sends it → replies come back and get classified by AI (interested / not now / not interested / unsubscribe) → interested leads auto-create a task in the CRM. Sellable as "Personalized Outreach System — $2,000 setup + $1,000/mo" Use case 3: CRM automation Every sales team has the same problem: reps don't update the CRM. Automation removes the human dependency and keeps every record clean Resources: 1. HubSpot API (free tier) Link: https://developers.hubspot.com/docs/api/overview The most common CRM you'll integrate with 2. Pipedrive API (free tier) Link: https://developers.pipedrive.com/ 3. Attio API (free tier) Link: https://developers.attio.com/ New-school CRM that AI-native startups love Build this one workflow: Every time a meeting happens → transcript goes to an LLM → key fields extracted (next steps, pain points, decision maker, timeline) → HubSpot deal auto-updates → follow-up task assigned to the right person. Sellable as "CRM Autopilot — $1,500 setup + $750/mo" Use case 4: Content pipelines Highest margin of all, because output is infinite and clients measure value in pieces shipped Resources: 1. Blotato API (paid, free trial) Link: https://www.blotato.com/ Posts to every major platform from one API call 2. Buffer API (paid) Link: https://buffer.com/developers/api 3. Notion API (free) Link: https://developers.notion.com/ Where most content briefs live Build this one workflow: A topic enters from a Notion database → AI generates 6 platform-specific variants (X, LinkedIn, Instagram, TikTok, newsletter, thread) → workflow waits for human approval in Slack → auto-schedules via Buffer at optimal times. Sellable as "AI Content Engine — $2,500 setup + $1,000/mo" Use case 5: Meeting automation Every founder and every sales team spends hours in meetings and hours AFTER meetings writing things down. This entire post-meeting process can be fully automated Resources: 1. Fireflies.ai API (paid, free trial) Link: https://docs.fireflies.ai/ 2. Otter.ai API (paid) Link: https://otter.ai/api 3. AssemblyAI (free tier) Link: https://www.assemblyai.com/docs 4. OpenAI Whisper (open source, free) Link: https://github.com/openai/whisper Build this one workflow: Zoom meeting ends → Fireflies transcript arrives via webhook → LLM extracts action items, blockers, next meeting date → action items go into Linear or Asana → CRM deal auto-updates → personalized follow-up email draft gets sent to the rep's inbox to review. Sellable as "Meeting Autopilot — $1,200 setup + $600/mo" Use case 6: Internal knowledge bots Every company has sprawling internal knowledge that nobody can find. This is the highest-value RAG use case and it sells well Resources: 1. n8n RAG Templates (free) Link: https://n8n.io/workflows/?q=rag Pre-built n8n workflows for document ingestion and Q&A. Start here, you can build a working knowledge bot without writing any code 2. Supabase Vector (free tier) Link: https://supabase.com/docs/guides/ai Postgres + pgvector as a managed vector database. Perfect for small-to-mid client projects 3. LlamaIndex (developer track only) Link: https://docs.llamaindex.ai/ If you want to go deeper and build a fully custom RAG pipeline 4. LangChain RAG Tutorial (developer track only) Link: https://docs.langchain.com/oss/python/langchain/rag Build this one workflow: Documents get pulled from Notion or Google Drive → chunked and embedded → stored in Supabase Vector → an internal Slack bot answers questions by retrieving relevant chunks and citing them. Sellable as "Internal Knowledge Bot — $2,500 setup + $500/mo" Month 3 Milestone By the end of this month you should be able to: Pick and ship 1-2 polished, repeatable workflows from the list above Price each as a productized service with fixed scope and fixed price Demo each in under 3 minutes on a Loom Have at least 1 paying client (if you followed the Early Monetization section) or 1 free pilot in exchange for a case study If you have one paying client by the end of Month 3 (even for $300, means you're already winning) ⏩--------------------------------------------------------------------⏪ Month 4: Add AI agents to your toolbox (carefully) Your goal this month: Understand what "AI agents" actually are, know when to use them and (more importantly) when NOT to, and add agent-powered workflows to your service offering for the use cases where they genuinely make sense Warning: most of the "AI agent" content online is hype. You're going to stay grounded. 70% of the time an agent is the wrong choice. You're going to learn when it's the RIGHT choice and that knowledge will make you worth more than 90% of people selling agent services today What to learn: 1. What agents actually are (and aren't) An agent is NOT magic. It's a loop: the LLM thinks, picks a tool, the tool runs, the result goes back into the prompt, repeat until the task is done. That's it Every agent framework (n8n AI Agent node, LangGraph, CrewAI, AutoGen, Lindy, Relevance AI) just wraps this same loop differently Resources: 1. Anthropic: Building Effective Agents (free — MANDATORY reading) Link: https://www.anthropic.com/research/building-effective-agents The single best piece of writing on agents in production. Read this before you build anything agent-related. Not negotiable 2. OpenAI: A Practical Guide to Building Agents (free PDF) Link: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf Covers agent patterns, guardrails, and safety What to focus on: The perceive → plan → act → observe loop How a loop terminates (the model says "I'm done" or a max iteration cap hits) Why agents are just while loops with an LLM making branching decisions What every framework is actually abstracting away 2. Build your first agent (inside n8n) For the non-technical path, this is where you go. n8n's AI Agent node handles the loop, the tool calling, and the state management for you. You drag a node, give it a goal, connect it to "tool" sub-workflows, and watch it go Resources: 1. n8n AI Agent Node Docs (official, free) Link: https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/ The full reference for n8n's agent node. Read the whole thing 2. n8n AI Agent Templates (free) Link: https://n8n.io/workflows/?categories=AI Import 3 agent templates, run them, and reverse-engineer how they're wired. Worth a hundred tutorials What to focus on: Defining the agent's goal clearly in the system prompt Exposing the right tools to it (keep it small, 3-5 tools max for your first agent) Writing tool descriptions that are impossible to misinterpret Setting a max iteration limit (usually 10-15) so the agent can never loop forever Adding a human-in-the-loop approval step for any action that's irreversible Practice project: Build a support agent inside n8n that handles Tier 1 customer tickets. It should: Classify the ticket (billing, technical, account, feature request) For known issues, look up the fix in a knowledge base (Notion or Google Drive) and reply For account questions, pull info via a tool call For anything else, escalate to Slack with a full context summary Never send a reply without a confidence check 3. When to use agents vs. simple chains The most valuable thing you'll learn this month is when NOT to use agents The decision framework: Single LLM call: if the task can be solved in one prompt with enough context Fixed chain: if the steps are predictable and always run in the same order (most workflows!) Agent: only if the number of steps is genuinely unknown and depends on the input Resources: 1. Anthropic: "When to use agents" (free) Link: https://www.anthropic.com/research/building-effective-agents 2. Simon Willison: Designing Agentic Loops (free) Link: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/ Memorize this: A fixed chain of 3 LLM calls will always be faster, cheaper, and more debuggable than an agent that makes 3 calls. Reserve agents for genuinely open-ended tasks like research, multi-step customer support, or flexible sales outreach 4. Human-in-the-loop checkpoints Most serious business automations need a human approval step somewhere, especially when the agent is about to do something irreversible (send an email, post publicly, update a deal stage, charge a card) Resources: 1. n8n: Wait Node (free) Link: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/ n8n's built-in way to pause a workflow until a webhook or time trigger arrives. This is your approval gate 2. Slack Block Kit Builder (free) Link: https://api.slack.com/block-kit How to build interactive approval buttons in Slack messages What to focus on: Identifying which actions MUST have human approval (send, publish, pay, update) Building approval UIs in Slack, email, or a lightweight form Handling approve / reject / edit responses without corrupting state Timeouts for when no human responds 5. Making agents reliable (the part nobody shows in demos) Demo agents work. Production agents need actual reliability engineering What to focus on: Maximum iteration limits so an agent can never loop forever Per-tool retry with fallback Logging every tool call so you can debug what went wrong after the fact Adding a human escalation path for when the agent gets confused 6. (Developer path only) Python agent frameworks Skip this if you're on the non-technical track If you want the dev track, these unlock custom agent work that clients pay more for: 1. LangGraph (free course) Link: https://academy.langchain.com/courses/intro-to-langgraph The most widely used agent orchestration framework 2. CrewAI (free, open source) Link: https://docs.crewai.com/ Multi-agent framework with role-based collaboration 3. AutoGen (Microsoft, free, open source) Link: https://microsoft.github.io/autogen/ Month 4 Milestone By the end of this month you should be able to: Build a working AI agent inside n8n that uses 3-5 tools reliably Confidently decide whether a task needs a single call, a fixed chain, or an agent Write tool descriptions that get selected correctly across varied inputs Add human-in-the-loop approval to any workflow that takes irreversible actions Know when to say "no, an agent is overkill here" to a client and offer them a simpler solution instead ⏩--------------------------------------------------------------------⏪ Month 5: Make your automations production-ready Your goal this month: Take everything you built in Months 1-4 and make it survive real clients, real traffic, and real 2am outages By the end you should be able to deploy, monitor, and hand off an automation to a non-technical client (and confidently promise them uptime and response time) What to learn: 1. Deployment (use Railway's 1-click n8n first) Good news: you don't need to learn Docker or DevOps this month. Railway has a 1-click n8n deploy. You click a button, add a custom domain, and you have a production n8n instance in 5 minutes Do that. Don't overthink it. Docker, reverse proxies, and Kubernetes come LATER, when you have 5+ clients and actually need them Resources: 1. Railway (free tier, recommended) Link: https://railway.app/ The fastest way to self-host n8n. Search for "n8n" in their templates and click deploy 2. Render (free tier) Link: https://render.com/docs/deploy-n8n Another great one-click option 3. n8n Cloud (hosted, paid) Link: https://n8n.io/cloud/ The zero-hassle option if a client doesn't want any infra at all. More expensive but no ops work on your end What to focus on: Deploying n8n on Railway with a custom domain and HTTPS Setting environment variables for secrets (never paste keys into the canvas) Setting up automatic backups Knowing what to do when it goes down (step 1: check Railway status page) (Developer path later): Self-hosting n8n with Docker Compose, managed Postgres, and a Caddy reverse proxy. Skip this until you have at least 3-5 clients 2. Logging and monitoring (know when it breaks before your client does) If you can't see what's happening inside your automation, you can't fix what's broken. And you'll only find out about the breakage when the client emails you at midnight Resources: 1. n8n Built-in Execution Logs (free) Link: https://docs.n8n.io/workflows/executions/ n8n's built-in logging is actually very good for most use cases. Master this first before adding anything else 2. Better Stack (free tier) Link: https://betterstack.com/ Uptime monitoring. Get paged when your n8n instance goes down 3. Langfuse (free tier) Link: https://langfuse.com/ LLM-specific observability. Traces every prompt, response, token count, and latency. Overkill for Month 5 but good to know exists What to focus on: Checking n8n execution logs daily for the first few weeks after deploying Setting up Better Stack to ping your n8n URL every minute and alert you if it goes down Alerting yourself in Slack or Telegram when a critical workflow fails Never finding out about an outage from your client 3. Prompt versioning (don't change prompts randomly in live workflows) Your prompts are code. They need version control. Random prompt changes in live workflows are how you silently break things Resources: 1. The boring option (recommended for beginners): store every prompt in a Notion database or Google Doc, label each version with a date, and always know which version is live 2. Langfuse Prompt Management (free tier) Link: https://langfuse.com/docs/prompts Centralized prompt storage with versioning and a built-in playground What to focus on: Never editing a live prompt in a client's workflow without testing it first Keeping the last 3 versions of every prompt so you can roll back Writing down WHY you changed a prompt every time you do 4. Security basics The fastest way to lose a client is to expose their API keys or let someone else access their data Resources: 1. OWASP Top 10 for LLM Apps (free) Link: https://genai.owasp.org/llm-top-10/ LLM-specific security risks including prompt injection. One hour read 2. n8n Credentials Docs (free) Link: https://docs.n8n.io/credentials/ How n8n stores API keys securely. Never paste a key into a node parameter (always use the credentials system) What to focus on: Never committing API keys to GitHub or any public doc Using n8n's built-in credentials vault for every API key Rotating keys if a workflow ever leaks one Sanitizing any user input before it hits an LLM (prompt injection defense) Never trusting LLM output to take irreversible actions without human review 5. Documentation and client handoff (the secret to 5x your rates) The difference between a $500 project and a $5,000 project is often just documentation. If you hand off a beautifully documented workflow with a Loom walkthrough, clients feel taken care of. If you hand off an unlabeled n8n canvas, they feel lost Resources: 1. Loom (free tier) Link: https://www.loom.com/ Record walkthrough videos for every workflow. 3-5 minutes each. Clients love these 2. n8n Sticky Notes (free) Link: https://docs.n8n.io/workflows/sticky-notes/ Use these extensively inside every workflow to explain what each section does 3. Notion Templates for Client Handoffs (free) Link: https://www.notion.so/templates Search for "client handoff" and steal shamelessly What to focus on: A one-page overview doc per automation: what it does, what triggers it, what it updates, what to do if it breaks Loom walkthroughs (3-5 min) for every non-trivial workflow Sticky notes inside every n8n canvas explaining WHY things are set up a certain way A simple runbook listing the 5 most likely failure modes and how to resolve them Training the client on how to check the monitoring dashboard themselves 6. Basic SLAs Once you charge retainers, clients will ask what you're promising and what happens when you miss it. You don't need enterprise contracts. You need clarity What to focus on: Uptime commitment (99% is reasonable for automation work) Response time for issues (reply within X hours, fix within Y) Scope boundaries (what's included, what's an extra) Escalation path for urgent failures Month 5 Milestone By the end of this month you should be able to: Deploy any of your workflows to Railway in under 10 minutes Set up monitoring that alerts you BEFORE clients notice something broke Hand off a clean package to any client: workflow, Loom, runbook, and a monitoring dashboard Write and negotiate a basic SLA for retainer work Sleep peacefully knowing your workflows are being watched ⏩--------------------------------------------------------------------⏪ Month 6: Pick your direction and scale By this point you have: 1-2 workflows that actually work, at least 1 paying client (hopefully more), a deployed production setup, and the beginnings of a portfolio. Month 6 is about picking which direction you scale in Three real paths. Pick ONE and go all in Direction 1: Freelance Automation Builder Best if you want clients fast and income in 30-60 days This is the fastest path to real income. You sell workflow builds and retainers directly to SMBs, agencies, coaches, and SaaS founders. Low overhead, high margins, cash in weeks Focus on: 2-3 repeatable workflow templates (lead gen, cold outreach, content pipeline, support bot) A simple case study for each with real numbers Cold outreach to SMBs, agencies, coaches, and SaaS founders Pricing structure: $500-2k per project to start, move to $1-3k/mo retainers as you get reviews What to learn this month: 1. Productizing your services Stop selling hours. Start selling outcomes. "Lead Gen Pipeline Setup — $1,500" converts 10x better than "Custom automation work, hourly rate" Resources: 1. Productized Services Guide (Pieter Levels, free) Link: https://nomadlist.com/forum/post/3471 2. Sahil Lavingia's blog (free) Link: https://sahillavingia.com/ What to focus on: Pick 2-3 services, write fixed scopes and fixed prices for each Build a portfolio site (Notion page or Carrd is enough) showcasing only those services Never say yes to custom work you haven't productized yet 2. Cold outreach and client acquisition You have to sell. There's no way around it. Good news: you already built the exact tools you'll use for your own outreach during Month 3 Resources: 1. Instantly Blog (free) Link: https://instantly.ai/blog 2. Nick Saraev (YouTube, free) Link: https://www.youtube.com/@nicksaraev Specifically focused on automation agency outreach and sales What to focus on: Building a lead list of 500-1000 companies in your target niche Writing a personalized cold email pitching ONE specific automation with a clear ROI claim Booking 3-5 discovery calls per week Closing a "Build First, Pay After" pilot offer to get your first case study 3. Case studies and social proof One well-documented case study will bring you more clients than 500 outreach emails. Build your first one the moment you ship your first project What to focus on: Before/after metrics (time saved, revenue generated, cost reduced) A clear story: problem → what you built → result Loom walkthrough of the workflow for visual proof Client testimonial quote Direction 2: In-House Automation Builder Best if you want stability and a salary This direction is for people who want the safety of a full-time role inside one company, building internal automation systems that save the business time and money Focus on: Ops and internal tooling use cases Connecting AI to existing company stack (Slack, Notion, HubSpot, Salesforce) Building internal agents and dashboards Measuring time and cost savings rigorously What to learn this month: 1. Internal tool building Resources: 1. Retool (free tier) Link: https://retool.com/ The standard for building internal tools fast 2. Streamlit (open source, free) Link: https://streamlit.io/ The fastest way to build Python-powered internal tools 3. Budibase (open source, free) Link: https://budibase.com/ Open source Retool alternative What to focus on: Identifying the highest-value automation targets inside your company Building simple UIs non-technical employees can actually use Getting sign-off and resource allocation from stakeholders 2. Measuring ROI properly In-house builders get promoted based on measurable business impact. If you can't prove your automations saved X hours or $Y, you're invisible What to focus on: Tracking before/after metrics for every automation you ship Presenting numbers in monthly wins docs Calculating direct (time saved) and indirect (errors reduced, satisfaction improved) impact Getting stakeholder quotes you can reuse in your next performance review and job search 3. Career positioning What to focus on: Writing internal docs and blog posts about your automation wins Presenting at internal meetings, demo days, all-hands Sharing (sanitized) case studies on LinkedIn and X Keeping a "projects built" doc you can show at every performance review Direction 3: AI Automation Agency Best if you want to scale beyond trading time for money This is the highest-ceiling path but also the hardest. You build a team, a repeatable service, and a real business (not just a freelance income) Focus on: Building a repeatable service with clear deliverables Hiring or partnering to fulfill work Niching down by industry (real estate, e-commerce, recruiting, legal) Productizing workflows into templates you sell or license What to learn this month: 1. Building a repeatable service An agency only works if the same service can be delivered by multiple people the same way. This is what separates agencies from freelancers Resources: 1. The E-Myth Revisited (book) Link: https://www.amazon.com/E-Myth-Revisited-Small-Businesses-About/dp/0887307280 The classic on systematizing a services business. Mandatory reading before you hire anyone 2. Built to Sell (book) Link: https://www.amazon.com/Built-Sell-Creating-Business-Without/dp/1591845823 Specifically about making your agency independent of you What to focus on: Documenting every step of your delivery process as SOPs Defining deliverables and timelines explicitly Productized pricing: "Lead Gen Package — $3,500 one-time + $750/mo" 2. Niching down Generalist agencies die. Niche agencies thrive. Pick one industry and own it What to focus on: Researching 3-5 industries and picking one where you have context, pricing is high, and the problem is universal Building niche-specific templates and case studies Rewriting your portfolio and outreach around that niche 3. Hiring and delegating Resources: 1. OnlineJobs.ph (paid, international) Link: https://www.onlinejobs.ph/ 2. Upwork (free, global) Link: https://www.upwork.com/ What to focus on: Hiring operators first (people who can run existing workflows and talk to clients) Writing task-level SOPs before hiring anyone Keeping the first hire part-time until you're sure the work is there Not hiring until you have at least 3 paying clients Practice project for Direction 3 Pick one industry (e.g. real estate). Build 3 workflows that solve the 3 biggest repetitive problems in that industry (lead qualification, listing description generation, appointment reminders). Package them as "Real Estate AI Automation Suite" with fixed pricing and a clear deliverables list. This is a sellable product you can take to market on day one ⏩--------------------------------------------------------------------⏪ CONCLUSION What you can expect after these 6 months??? I'm going to be honest with you, without any "money's mountains" This roadmap will not make you the next Zapier CEO in 6 months But it will make you someone who can build, ship, and deploy real AI automations that solve real business problems And right now, that is exactly what the market is paying for AI automation demand is not slowing down. LinkedIn's 2026 Jobs on the Rise report puts "AI automation specialist" in the top 5 fastest-growing roles McKinsey estimates that 60-70% of employee time in most office roles is automatable with current AI + workflow tools Only about 2% of SMBs have implemented any meaningful AI automation so far, which means 98% of the market is still completely untouched These are not hype numbers. These are real numbers based on real data (took from Claude kek) If you go full-time in the US or EU: 1: Junior AI Automation Builders start at $75,000-$110,000 2: Mid-level (2-4 years) sits at $125,000-$180,000 3: Senior builders and automation architects go $180,000-$280,000+ The mid-level band is growing the fastest because companies desperately need people who can ship reliable production automations without supervision If freelance is more your thing: 4: AI workflow builds go for $500-5,000 per project 5: Monthly retainers start at $500-2,000/mo for basic maintenance and land at $3,000-8,000/mo for active development 6: Hourly rates for specialist automation work are $100-250/hour depending on niche I personally know freelancers pulling $15,000/month solo just building n8n workflows for SMBs. The work exists and the market is still desperately underserved And if you go the consulting or agency route: 7: $500-5,000 to set up a single AI automation for a business 8: $1,000-5,000/month for managed automation services 9: $3,000-15,000 to build a full custom agent system 10: $10,000-50,000 for enterprise-grade automation packages The ceiling is genuinely uncapped. I've seen 2-person automation agencies doing $80k/mo in recurring revenue serving 15-20 clients These are real numbers from real people doing real work right now in 2026 Now here is what I actually want you to take away from all of this: Pick one workflow from each month and build it. Not read about it. Not watch a tutorial. Build it, break it, fix it, deploy it, put it on GitHub or in a portfolio site. The builders who get hired are the ones who show what they've built, not what they've studied Start sharing what you learn. Write about it on X, LinkedIn, anywhere. Teaching is the fastest way to learn and it builds your reputation at the same time. The best clients I've seen come from people who were visible, not from people who applied to 500 job listings And please don't wait until you feel ready. You will never feel ready. The gap between "I'm learning" and "I'm building" is where most people get stuck forever Start applying, start freelancing, start offering services the moment you have ONE working automation. Even if it's rough. The market doesn't reward perfection. It rewards people who can ship 6 months is enough to change everything if you actually put in the work And I really believe each of you reading this can do it Just never stop building and never stop learning Hope this was useful for you my fam ❤️

泉水の/注目
ニュース&ポスト Slackを見なくても、今朝のAI業界の動きが
ここで網羅できる。亮介が毎朝選ぶ05本。

Claude Design by Anthropic Labs 発表

Cursor、Claude Opus 4.7 に即日対応 & Composer 2 週末ダブル枠

Gemini Robotics、Boston Dynamics の Spot に搭載

NotebookLM にカスタムカバーアートと Gemini App Notebooks の Free 開放

xAI、Grok Build を来週ベータ公開予定