- 🇮🇩 Bahasa Indonesia
- 🇬🇧 English
Ubah brief produk menjadi landing page siap konversi yang live dalam hitungan jam, bukan minggu. Pipeline riset-ke-eksekusi 9-langkah yang dibuat untuk Hermes Agent, digerakkan oleh AI agent terstruktur, artifak JSON, dan tanpa "vibes" kosong.
Masalah: Agency mengenakan biaya retainer mahal dan masih membutuhkan waktu 4–6 minggu hanya untuk merilis satu landing page. Solo founder membakar uang untuk iklan yang mengarahkan trafik ke halaman yang dirasa "sudah pas" tapi sebenarnya tidak pernah divalidasi terhadap psikologi pembeli riil.
Solusi: Sebuah pipeline otonom yang digerakkan oleh AI agent untuk memadatkan riset, positioning, strategi CRO, dan pembuatan landing page menjadi satu alur kerja yang koheren. Setiap langkah berbasis artifak (schema JSON), setiap output dapat dilacak (traceable), dan setiap keputusan didasarkan pada data pelanggan yang sama.
Prinsip Utama:
- Dampak di atas sekadar output — kami tidak hanya merilis "sebuah landing page." Kami memberikan probabilitas konversi.
- Artifak yang utama (Artifact-first) — setiap langkah menghasilkan artifak JSON ramah mesin dengan skema ketat. Langkah berikutnya membaca data tersebut, bukan manusia.
- Berbasis Peran (Role-based) — kami tidak menargetkan "segmen umum." Kami menargetkan manusia pengambil keputusan dalam peran hidup (life roles) spesifik.
- Tanpa spekulasi kosong (No hand-waving) — setiap wawasan (insight) harus dapat dilacak ke langkah sebelumnya. Jika tidak ada di dalam artifak, maka dianggap tidak ada.
Ini untuk Anda jika:
- Anda adalah solo founder, indie hacker, atau tim kecil tanpa anggaran untuk biaya retainer agency yang mahal ($5k+/bulan).
- Anda menjalankan iklan berbayar dan membutuhkan landing page yang benar-benar cocok dengan psikologi pembeli di balik klik tersebut.
- Anda memiliki brief produk tetapi tidak tahu bagaimana cara menerjemahkannya menjadi pesan marketing, positioning, dan halaman yang live.
- Anda menginginkan beberapa rencana CRO dan varian A/B, bukan hanya satu halaman yang "cukup baik."
- Anda peduli dengan keterlacakan (traceability) — setiap headline harus dibenarkan oleh riset, bukan intuisi semata.
Ini BUKAN untuk Anda jika:
- Anda menginginkan situs animasi 3D kustom dengan shader WebGL khusus. Pipeline ini menghasilkan HTML statis yang bersih, cepat, dan fokus pada konversi.
- Anda membutuhkan checkout e-commerce lengkap dengan integrasi payment gateway. Outputnya adalah landing page (lead capture / sales page), bukan toko online penuh.
- Anda mengharapkan sistem yang "sekali pasang lalu lupakan" tanpa meninjau outputnya. Pipeline ini berjalan otomatis, tetapi Anda tetap perlu membaca rencana CRO dan laporan QA sebelum merilisnya.
- Anda mencari pembuat drag-and-drop tanpa kode (no-code builder). Ini adalah pipeline yang digerakkan oleh agent bagi orang-orang yang ingin merilis HTML murni.
| Lapisan | Teknologi | Mengapa |
|---|---|---|
| Orkestrasi | Hermes Agent + pipeline.yaml |
Pengiriman agent asli, logika coba ulang (retry), dan perutean artifak |
| Definisi Agent | YAML dengan system_prompt, input_artifacts, output_artifact |
Kontrak eksplisit, mencegah penyimpangan prompt |
| Format Data | Artifak JSON + JSON Schema Draft-07 | Terstruktur ramah mesin, divalidasi, dan memiliki versi |
| Gaya/Styling | Tailwind CSS via CDN | Tanpa langkah build tambahan, cepat, ramah seluler (mobile-first) |
| Tipografi | Google Fonts (default: Inter) | Bersih, mudah dibaca, dioptimalkan untuk web |
| Output | HTML5 Statis (tanpa JS bawaan) | Pemuatan tercepat, tanpa beban framework, meminimalisir celah keamanan |
| QA | Audit Red-team + validasi skema | Keamanan otomatis sebelum ditinjau oleh manusia |
| Kontrol Versi | Git + metadata.brief_hash |
Setiap artifak dapat dilacak kembali ke brief input aslinya |
| Langkah | Agent | Peran | Artifak Output |
|---|---|---|---|
| 01 | agent-01 |
Analisis Pasar Sasaran | 01-market/target-market-analysis.json |
| 02 | agent-02 |
Analisis Mendalam JTBD (Christensen-Moesta) | 02-jtbd/jtbd-analysis.json |
| 03 | agent-03 |
Analisis Mendalam JTBD v2 (Peta Kerja Mendalam) | 03-jtbd-v2/jtbd-v2-analysis.json |
| 04 | agent-04 |
Profil Peran Hidup (Life Role Profile) | 04-role/role-profile.json |
| 05 | agent-05 |
Basis Data Motivasi Pelanggan | 05-motivation/customer-motivation-database.json |
| 06 | agent-06a/b/c |
Peluang Strategis & Positioning | 06-opportunity/strategic-analysis.json |
| 07 | agent-07 |
Pembuat Rencana CRO | 07-cro/cro-plan.json + 07-cro/plans/plan-*.json |
| 08 | agent-08 |
Pembuat Landing Page (HTML/CSS) | 08-lp/primary/ + 08-lp/challenger/ |
| 09 | agent-09 |
Laporan QA & Audit Red Team | 09-qa/qa-report.json |
Orkestrator: pipeline.yaml (definisi YAML) + scripts/run.py (titik masuk eksekusi).
Ruang Lingkup: Menerima brief produk (teks/markdown) dan menghasilkan peta pasar yang ketat dengan minimal 5 segmen, 1 Profil Pelanggan Ideal (ICP), 20 poin rasa sakit (pain points), 20 keinginan (desires), 20 ketakutan (fears), 20 keberatan (objections), 20 frasa bahasa sehari-hari, dan rincian tingkat kesadaran pelanggan (awareness-level).
Detail Teknis:
- Input: brief produk mentah (teks apa saja hingga ~10k karakter).
- Output: skema ketat
schema-01.json(JSON Schema Draft-07). Jumlah array minimum diberlakukan (minItems: 20). - Penilaian: setiap segmen mendapatkan
score(1–10) untuk menghitung peringkat prioritas.
Dampak: Anda akan tahu persis kepada siapa Anda menjual, apa sebutan mereka untuk masalah mereka, dan mengapa mereka belum membeli produk Anda. Tanpa tebakan persona.
Ruang Lingkup: Mengonsumsi artifak Langkah 01 dan memetakan Jobs To Be Done menggunakan kerangka kerja Christensen-Moesta. Mengidentifikasi pekerjaan fungsional, emosional, dan sosial. Membangun cerita pekerjaan (job stories), peta kemajuan, kriteria perekrutan, dan kekuatan beralih (switching forces).
Detail Teknis:
- Input:
01-market/target-market-analysis.json. - Output:
schema-02.jsondenganjob_list,job_stories,progress_map,job_drivers,job_blockers,hiring_criteria. - Skor tingkat kepercayaan (confidence score) per bidang.
Dampak: Anda akan memahami mengapa ICP memilih/membeli suatu produk — bukan apa yang mereka katakan mereka inginkan, melainkan kemajuan apa yang sebenarnya ingin mereka capai.
Ruang Lingkup: Menganalisis silang output Langkah 02 dan menghasilkan peta kerja yang lebih mendalam: pekerjaan aktual vs. aspirasional, tahapan peta kerja, perjalanan emosional, pemicu situasional, solusi alternatif, dan hambatan untuk beralih.
Detail Teknis:
- Input:
02-jtbd/jtbd-analysis.json. - Output:
schema-03.jsondengan detail tahapan perjalanan pembeli sebelum membeli produk Anda.
Dampak: Mengidentifikasi celah dalam perjalanan pembelian di mana pelanggan biasanya menyerah, sehingga Anda bisa membuat penawaran yang menutup celah tersebut.
Ruang Lingkup: Menerjemahkan data pasar abstrak menjadi profil peran hidup konkret. Mengidentifikasi tanggung jawab utama, konflik peran, pengaruh sosial, dan bagaimana produk ini pas dengan identitas keseharian mereka.
Detail Teknis:
- Input:
03-jtbd-v2/jtbd-v2-analysis.json. - Output:
schema-04.jsonyang memetakan relasi sosial pembeli (misal: sebagai ibu rumah tangga sekaligus pekerja paruh waktu).
Dampak: Membuat salinan tulisan (copywriting) yang berbicara langsung pada identitas mereka, meningkatkan resonansi emosional halaman secara signifikan.
Ruang Lingkup: Membangun basis data motivasi komprehensif yang berisi pemicu internal dan eksternal, hambatan psikologis, serta insentif yang dapat mendorong konversi secara etis.
Detail Teknis:
- Input:
04-role/role-profile.json. - Output:
schema-05.jsondengan daftar pemicu motivasi terstruktur.
Dampak: Menyediakan bahan baku copywriting mentah yang langsung menyasar keinginan terdalam calon pembeli.
Ruang Lingkup: Menilai opsi sudut pandang (angles) penawaran produk menggunakan tiga variasi agent independen (06a, 06b, dan 06c - Principal) untuk menentukan posisi terbaik di pasar.
Detail Teknis:
- Input:
05-motivation/customer-motivation-database.json. - Output:
schema-06.jsonberisi analisis perbandingan sudut pandang marketing.
Dampak: Menghindari bias subjektif dengan mensimulasikan tiga sudut pandang strategi pemasaran yang berbeda dan memilih yang paling efektif secara objektif.
Ruang Lingkup: Menerjemahkan strategi terpilih menjadi rencana Optimasi Tingkat Konversi (Conversion Rate Optimization / CRO) terstruktur yang mencakup hierarki pesan, elemen kepercayaan, dan penawaran utama.
Detail Teknis:
- Input:
06-opportunity/strategic-analysis.json. - Output:
schema-07.jsonyang memuat rencana A/B testing (Primary vs Challenger).
Dampak: Memiliki blueprint arsitektur informasi halaman yang siap diimplementasikan tanpa menebak urutan bagian (section).
Ruang Lingkup: Menghasilkan kode HTML/CSS statis ramah seluler menggunakan utility classes dari Tailwind CSS, berdasarkan instruksi ketat dari rencana CRO Langkah 07.
Detail Teknis:
- Input:
07-cro/plans/plan-*.json. - Output: File HTML lengkap di direktori
08-lp/primary/dan08-lp/challenger/.
Dampak: Landing page murni tanpa beban framework JavaScript yang langsung siap diunggah ke server hosting Anda dengan performa super cepat.
Ruang Lingkup: Melakukan pemeriksaan kualitas menyeluruh secara otomatis untuk mendeteksi taktik manipulasi psikologis (dark patterns), manipulasi skrip (scarcity palsu), kepatuhan regulasi, serta keutuhan tautan halaman.
Detail Teknis:
- Input: Direktori output dari
08-lp/. - Output:
schema-09.jsonberisi status kelulusan (PASS/FAIL) audit.
Dampak: Menghindari risiko pemblokiran iklan atau sanksi hukum akibat klaim berlebih atau taktik scarcity palsu sebelum halaman dipublikasikan.
┌─────────────────────────────────────────────────────┐
│ Brief (Teks/Markdown) │
└────────────┬────────────────────────────────────────┘
│
┌────────────▼────────────────────────────────────────┐
│ Pipeline Orchestrator (pipeline.yaml) │
│ - Maksimal 2 kali coba ulang (retry loops) per step │
│ - Checkpoint auto-jalan (auto-proceed) │
│ - Validasi artifak ketat setelah setiap langkah │
└────────────┬────────────────────────────────────────┘
│
┌────────────▼────────────────────────────────────────┐
│ Step 01 → 02 → 03 → 04 → 05 → 06 → 07 → 08 → 09 │
│ Tiap langkah: Agent membaca JSON lama, menulis baru │
│ Tanpa intervensi manusia di tengah jalan (mode auto)│
└────────────┬────────────────────────────────────────┘
│
┌────────────▼────────────────────────────────────────┐
│ Hasil Akhir (Deliverables): │
│ - 09-qa/qa-report.json (PASS / FAIL) │
│ - 08-lp/primary/ (HTML langsung pakai) │
│ - 08-lp/challenger/ (HTML alternatif) │
│ - 07-cro/plans/ (Arsip rencana cadangan) │
└─────────────────────────────────────────────────────┘
Setiap langkah menghasilkan artifak JSON yang divalidasi terhadap JSON Schema (Draft-07) yang ketat. Ini bukan sekadar dokumentasi — ini adalah kontrak pertukaran data antar agent.
schemas/schema-01.jsonhinggaschema-09.jsonmenentukan bentuk data, kolom wajib, serta batasan min/max data.schemas/schema-09-lite.jsonmenentukan kontrak QA ringan untuk mode pemrosesan massal (batch mode).- Jika output agent gagal lolos validasi skema, orkestrator akan otomatis mencoba ulang langkah tersebut (maksimal 2 kali).
- Jika masih gagal setelah batas percobaan, pipeline akan berhenti dan mencatat detail error ke log.
Mengapa ini penting: Agent tidak membaca paragraf panjang yang tidak terstruktur dengan baik. Mereka membaca data terstruktur. Pipeline ini berjalan deterministik karena input dari setiap langkah adalah output langsung dari langkah sebelumnya.
performance-ngegas/
├── agents/ # Definisi Agent (YAML: nama, peran, system_prompt, input, output)
│ ├── agent-01.yml # Target Market Analyst
│ ├── agent-02.yml # JTBD Researcher
│ ├── agent-03.yml # JTBD Deep Map v2
│ ├── agent-04.yml # Role Profiler
│ ├── agent-05.yml # Motivation Database Builder
│ ├── agent-06a.yml # Opportunity Analyst (Varian A)
│ ├── agent-06b.yml # Opportunity Analyst (Varian B)
│ ├── agent-06c.yml # Opportunity Analyst (Varian C — Utama)
│ ├── agent-07.yml # CRO Strategist
│ ├── agent-08.yml # LP Builder
│ ├── agent-09.yml # QA & Red Team Auditor
│ └── agent-09-lite.yml # QA Lite (Batch Mode)
├── prompts/ # Prompt lengkap untuk setiap langkah (Markdown)
│ ├── 01-target-market-analysis.md
│ ├── 02-jtbd-deep-analysis.md
│ ├── 03-jtbd-deep-analysis-v2.md
│ ├── 04-role-profile.md
│ ├── 05-customer-motivation-database.md
│ ├── 06-strategic-opportunity.md
│ ├── 07-cro-plan.md
│ └── 08-landing-page-builder.md
├── schemas/ # Kontrak JSON Schema (Draft-07)
│ ├── schema-01.json # Target Market Analysis
│ ├── schema-02.json # JTBD Analysis
│ ├── schema-03.json # JTBD v2
│ ├── schema-04.json # Role Profile
│ ├── schema-05.json # Customer Motivation Database
│ ├── schema-06.json # Strategic Opportunity
│ ├── schema-07.json # CRO Plan
│ ├── schema-08.json # Landing Page Implementation
│ ├── schema-08-qa.json # QA metadata untuk LP
│ ├── schema-09.json # QA Laporan Akhir
│ └── schema-09-lite.json# QA Laporan Lite
├── references/ # Dokumen metodologi, pola eksekusi, & solusi masalah
│ ├── methodology.md
│ ├── pipeline-orchestration.md
│ ├── run-patterns.md
│ ├── brief-validator.md
│ ├── landing-page-constraints.md
│ ├── qa-step-09-optimization.md
│ └── ...
├── scripts/ # Skrip pembantu eksekusi
│ ├── run.py # Titik masuk utama
│ ├── cro-plan-health-check.py
│ ├── generate-audit-input.py
│ └── qa-script.py
├── .planning/ # Perencanaan proyek & dokumen persyaratan
│ ├── PROJECT.md
│ ├── REQUIREMENTS.md
│ └── ROADMAP.md
├── pipeline.yaml # Konfigurasi orkestrasi pipeline
└── SKILL.md # Manifest skill untuk Hermes Agent
Skenario alur kerja dari brief seorang founder:
User: "Saya menjual langganan jus cold-pressed untuk kalangan profesional sibuk di Jakarta.
Target: Usia 25-40, peduli kesehatan, kekurangan waktu, skeptis dengan klaim 'detox' berlebihan.
Batasan: Harus mematuhi aturan label BPOM. Tidak boleh menggunakan scarcity palsu."
Hermes: skill: performance-ngegas
Pipeline berjalan:
01 → 02 → 03 → 04 → 05 → 06 → 07 → 08 → 09
Hasil Akhir:
- 08-lp/primary/index.html (Headline: "Capek Terus? Mungkin Bukan Kurang Tidur")
- 08-lp/challenger/index.html (Headline: "3 Hari Tanpa Kafein = Lebih Fokus Kerja")
- 07-cro/plans/plan-archive.json (Rencana CRO tersimpan untuk kampanye Ramadan nanti)
- 09-qa/qa-report.json (PASS, 0 temuan red-team)
Langkah-demi-langkah:
-
Muat Skill:
skill: performance-ngegas -
Kirimkan Brief Anda: Tempelkan penjelasan singkat produk atau layanan Anda. Sertakan:
- Deskripsi produk
- Petunjuk target audiens
- Batasan (regulasi BPOM, pedoman brand, batasan teknis)
-
Jalankan: Orkestrator (
pipeline.yaml) akan mendistribusikan tugas ke masing-masing agent secara berurutan. Setiap agent otomatis membaca file JSON sebelumnya dan menulis artifak JSON berikutnya. -
Tinjau Rencana CRO: Before the build starts, read
07-cro/plans/plan-01.json. If the messaging feels off, you can adjust the brief and re-run. The pipeline is fast enough to iterate. -
Terima Hasil Jadi:
08-lp/primary/index.html— Landing page utama Anda.08-lp/challenger/index.html— Varian alternatif untuk pengujian A/B testing.07-cro/plans/— Arsip rencana CRO untuk referensi kampanye mendatang.09-qa/qa-report.json— Laporan audit QA lengkap dengan skor validasi.
-
Deploy: Kode HTML yang dihasilkan bersifat statis dan siap diunggah ke layanan hosting apa pun (Caddy, Vercel, Netlify, S3, atau VPS Anda).
- Validasi Skema: Setiap artifak JSON diperiksa keabsahannya terhadap JSON Schema sebelum langkah berikutnya dapat dimulai.
- Skor Kepercayaan (Confidence Score): Setiap agent memberikan skor kepastian atas analisisnya. Jika skor berada di bawah ambang batas minimum, sistem akan memberikan peringatan.
- Audit Red Team: Langkah 09 menyisir file output untuk mendeteksi manipulasi waktu/stok (
Math.random, hitung mundur palsu), memeriksa ketersediaan disclaimer BPOM, dan memvalidasi keutuhan struktur tag HTML. - Batas Percobaan Ulang: Maksimal 2 kali coba ulang per langkah. Jika masih gagal, pipeline dihentikan demi menjaga integritas data.
- Bebas JavaScript Berlebih: Langkah 08 menghasilkan HTML murni. Tanpa framework berat, tanpa skrip pelacakan tersembunyi, dan tanpa JS yang tidak diperlukan.
- Audit Trail Komprehensif: Setiap file menyertakan
metadataberisi informasitimestamp,agent,brief_hash, danpipeline_version.
| Alih-alih mendapatkan... | Anda mendapatkan... |
|---|---|
| Landing page yang sekadar "terlihat cantik" | Halaman dengan rekayasa persuasi psikologis berdasarkan urutan bagian dan hierarki pesan yang teruji |
| Copywriting hasil tebakan | Salinan tulisan yang dirumuskan langsung dari masalah nyata, ketakutan, keinginan, dan bahasa sehari-hari target pembeli |
| Strategi tunggal yang kaku | Beberapa pilihan rencana CRO bernilai skor tinggi (Utama + Varian Alternatif + Arsip) |
| Waktu tunggu berminggu-minggu | Pipeline lengkap dari brief kasar hingga landing page siap rilis dalam hitungan jam |
| Asumsi yang tidak tervalidasi | Setiap wawasan memiliki skor kredibilitas dan sumber referensi yang jelas dari tahap riset sebelumnya |
| Risiko pelanggaran hukum / manipulasi data | Audit Red-Team mendeteksi dan membersihkan pelanggaran sebelum Anda mengunggahnya ke server |
Untuk memastikan ekspektasi yang realistis, berikut adalah beberapa hal yang secara eksplisit tidak dilakukan oleh pipeline ini:
| Pola Salah Kaprah | Alasan Pengecualian |
|---|---|
| Mengarang/Memalsukan Data | Setiap wawasan harus dapat dilacak dari artifak sebelumnya. Jika data riset terlalu tipis, output akan ditandai sebagai Assumption (Asumsi) — bukan fakta. |
| Copywriting Seragam | Pipeline membangun variasi landing page berdasarkan rencana CRO. Jika rencana menunjukkan dua audiens membutuhkan sudut pandang pemicu yang berbeda, Anda akan mendapatkan dua halaman terpisah. |
| Manipulasi Urgensi / Trik Gelap | Audit Red-Team (Langkah 09) memblokir kode yang menggunakan generator angka acak untuk memalsukan sisa stok atau waktu promo. Jika terdeteksi, pipeline otomatis dihentikan. |
| Logika Backend Kustom | Hasil akhir berupa HTML statis murni. Tanpa sistem pembayaran bawaan, tanpa otentikasi pengguna, dan tanpa basis data. Integrasikan dengan layanan pihak ketiga atau form handler Anda sendiri. |
| Konten Blog SEO | Ini adalah pipeline landing page untuk konversi iklan, bukan mesin pembuat konten artikel SEO untuk mendatangkan trafik organik. |
| Revisi Tanpa Batas | Batas coba ulang otomatis adalah 2 kali per langkah. Jika masih gagal, pipeline dihentikan agar kesalahan dapat diidentifikasi secara manual oleh pengguna sebelum dilanjutkan. |
- Dokumen perencanaan proyek lengkap, kebutuhan sistem, dan peta jalan jangka panjang tersedia di folder
.planning/. - Silakan merujuk ke
.planning/PROJECT.mduntuk memahami latar belakang dan keputusan desain arsitektur. - Silakan merujuk ke
.planning/REQUIREMENTS.mduntuk daftar kebutuhan fungsional dan non-fungsional sistem. - Silakan merujuk ke
.planning/ROADMAP.mduntuk melihat rencana rilis fase dan milestone mendatang.
- Tidak ada kredensial pribadi, API key, atau token yang disimpan di repositori ini. Repositori ini berisi metodologi dan definisi agent. Anda menjalankannya menggunakan API key LLM dan infrastruktur server Anda sendiri.
- Bukan klaim medis, keuangan, atau hukum. Pipeline ini menghasilkan aset pemasaran statis. Anda sepenuhnya bertanggung jawab untuk memastikan kepatuhan terhadap regulasi lokal (seperti BPOM, kementerian kesehatan, aturan periklanan setempat) sebelum meluncurkan halaman secara luas.
- Kinerja penjualan/konversi tidak dijamin. Label "siap konversi" berarti halaman dibangun menggunakan prinsip riset ilmiah yang tervalidasi. Tingkat konversi riil di lapangan akan selalu bergantung pada kualitas trafik iklan, kekuatan penawaran produk, kesesuaian pasar, serta faktor eksternal lainnya yang berada di luar jangkauan teknis pipeline ini.
Dibuat untuk para solo founder dan tim gesit yang menginginkan landing page kelas agency tanpa harus menunggu berminggu-minggu.
Turn product briefs into live, conversion-ready landing pages in hours instead of weeks. 9-step research-to-execution pipeline built for Hermes Agent, driven by structured AI agents, JSON artifacts, and zero hand-waving.
Problem: Agencies charge retainers and still take 4–6 weeks to deliver a single landing page. Solo founders burn cash on ads that send traffic to a page that "feels right" but was never validated against real buyer psychology.
Solution: A fully autonomous, agent-driven pipeline that compresses research, positioning, CRO strategy, and landing page build into a single coherent workflow. Every step is artifact-first (JSON schema), every output is traceable, and every decision is grounded in the same customer data.
Core principles:
- Outcome over output — we don't deliver "a landing page." We deliver conversion probability.
- Artifact-first — every step produces a machine-readable JSON artifact with strict schema. The next step reads it, not the human.
- Role-based — we don't target "segments." We target decision-making humans in specific life roles.
- No hand-waving — every insight must be traceable to prior steps. If it's not in the artifact, it doesn't exist.
This is for you if:
- You are a solo founder, indie hacker, or small team with no budget for a $5k+/month agency retainer.
- You run paid ads and need a landing page that actually matches the buyer psychology behind the click.
- You have a product brief but no idea how to turn it into messaging, positioning, and a live page.
- You want multiple CRO plans and A/B variants, not just one "good enough" page.
- You care about traceability — every headline must be justified by research, not vibes.
This is NOT for you if:
- You want a bespoke 3D animated site with custom WebGL shaders. This pipeline outputs clean, fast, conversion-focused static HTML.
- You need a full e-commerce checkout with payment gateway integration. The output is a landing page (lead capture / sales page), not a store.
- You expect "set it and forget it" without reviewing the output. The pipeline auto-runs, but you still need to read the CRO plan and QA report before shipping.
- You are looking for a no-code drag-and-drop builder. This is an agent-driven pipeline for people who want to deploy raw HTML.
| Layer | Technology | Why |
|---|---|---|
| Orchestration | Hermes Agent + pipeline.yaml |
Native agent dispatch, retry logic, and artifact routing |
| Agent definitions | YAML with system_prompt, input_artifacts, output_artifact |
Explicit contracts, no prompt drift |
| Data format | JSON artifacts + JSON Schema Draft-07 | Machine-readable, validated, versioned |
| Styling | Tailwind CSS via CDN | Zero build step, fast, mobile-first |
| Typography | Google Fonts (Inter default) | Clean, readable, web-optimized |
| Output | Static HTML5 (no JS) | Fastest possible load, no framework bloat, no security surface |
| QA | Red-team audit + schema validation | Automated safety before human review |
| Version control | Git + metadata.brief_hash |
Every artifact is traceable to its input brief |
| Step | Agent | What It Does | Output Artifact |
|---|---|---|---|
| 01 | agent-01 |
Target Market Analysis | 01-market/target-market-analysis.json |
| 02 | agent-02 |
JTBD Deep Analysis (Christensen-Moesta) | 02-jtbd/jtbd-analysis.json |
| 03 | agent-03 |
JTBD Deep Analysis v2 (Deep Job Map) | 03-jtbd-v2/jtbd-v2-analysis.json |
| 04 | agent-04 |
Life Role Profile | 04-role/role-profile.json |
| 05 | agent-05 |
Customer Motivation Database | 05-motivation/customer-motivation-database.json |
| 06 | agent-06a/b/c |
Strategic Opportunity & Positioning | 06-opportunity/strategic-analysis.json |
| 07 | agent-07 |
CRO Plan Generator | 07-cro/cro-plan.json + 07-cro/plans/plan-*.json |
| 08 | agent-08 |
Landing Page Builder | 08-lp/primary/ + 08-lp/challenger/ |
| 09 | agent-09 |
QA & Red Team Audit | 09-qa/qa-report.json |
Orchestrator: pipeline.yaml (YAML definition) + scripts/run.py (execution entry point).
Scope: Given a product brief (text/markdown), produce a rigorous market map with at least 5 segments, 1 Ideal Customer Profile (ICP), 20 pain points, 20 desires, 20 fears, 20 objections, 20 daily-language phrases, and an awareness-level breakdown.
Technical detail:
- Input: raw product brief (any text up to ~10k chars).
- Output: strict
schema-01.json(JSON Schema Draft-07). Minimum arrays enforced (minItems: 20). - Scoring: each segment gets a
score(1–10), priority ranking computed.
Promised outcome: You will know exactly who to sell to, what they call their pain, and why they haven't bought yet. No persona guessing.
Scope: Consume Step 01 artifact and map the Jobs To Be Done using the Christensen-Moesta framework. Identify functional, emotional, and social jobs. Build job stories, progress maps, hiring criteria, and switching forces.
Technical detail:
- Input:
01-market/target-market-analysis.json. - Output:
schema-02.jsonwithjob_list,job_stories,progress_map,job_drivers,job_blockers,hiring_criteria. - Confidence scoring per field.
Promised outcome: You will understand why the ICP hires a product — not what they say they want, but what progress they are actually trying to make.
Scope: Cross-reference Step 02 output and produce a deeper job map: actual vs. aspirational job, job-map stages, emotional journey, situational triggers, alternative solutions, and switching barriers.
Technical detail:
- Input:
01-market+02-jtbdartifacts. - Output:
schema-03.jsonwithdeep_job_maps,cross_reference_v1(consistencies/inconsistencies/reconciliations),trigger_words,switching_barriers. - If inconsistencies found, the agent must reconcile them and flag assumptions.
Promised outcome: A clean, validated job map with no contradictions — and a list of trigger words you can use in ads and headlines.
Scope: Shift from demographics to life roles. Map the buyer's roles (e.g., "stressed parent," "ambitious founder," "skeptical spouse") and identify which role dominates the purchase decision.
Technical detail:
- Input:
01-market,03-jtbd-v2artifacts. - Output:
schema-04.jsonwithlife_roles,actual_vs_aspirational,dominant_role,persona_variants. - Minimum 5 life roles, minimum 3 actual-vs-aspirational gaps.
Promised outcome: You will know which role is the real buyer — so your messaging speaks to the person writing the check, not a generic demographic.
Scope: Extract every root pain, surface pain, fear, desire, frustration, objection, and behavioral trigger into a structured, scored database. Every item must be traceable to prior steps (not invented).
Technical detail:
- Input: all prior artifacts (
01–04). - Output:
schema-05.jsonwithpain_points,desires,fears,frustrations,behavioral_triggers, each scored withseverity,frequency,surface_or_deep,confidence_score,evidence_type. - If evidence is weak, marked as
Assumption.
Promised outcome: A reusable database you can plug into landing pages, ads, sales scripts, and product strategy — without starting from scratch every time.
Scope: Synthesize everything into competitive positioning, opportunity sizing, and strategic recommendations. Don't repeat prior data — produce new insights from synthesis.
Technical detail:
- Input:
01–05artifacts. - Output:
schema-06.jsonwithcompetitive_analysis,opportunity_sizing,strategic_positioning,priority_recommendations. - Opportunity scoring formula:
(Importance × Urgency × Frequency × Market Gap)on 1–10 scale. - Competitive SWOT per competitor (minimum 5).
Promised outcome: A clear, defensible positioning and a ranked list of which opportunities to attack first — based on market gaps, not gut feeling.
Scope: Convert customer research into a concrete Conversion Rate Optimization plan with multiple variants (Primary / Challenger / Archive). Each plan includes section order, messaging hierarchy, conversion psychology, and A/B test hypotheses.
Technical detail:
- Input:
01–06artifacts. - Output:
schema-07.jsonwithplans(array, each scored),sections,ab_tests. - Variant types:
primary(execute now),challenger(test against),archive(keep permanently, manual activation). - Each plan scored on
conversion_probability,implementation_ease,strategic_fit. - Plan acts as the single source of truth for Step 08.
Promised outcome: A validated CRO plan that tells the builder exactly what sections to build, in what order, and why — so no one is guessing in the build phase.
Scope: Build the actual landing page. No invention. No extra sections. The builder reads the CRO plan and executes it faithfully into HTML, CSS, and assets.
Technical detail:
- Input:
07-cro/cro-plan.json+ selected plan (plan-01.json). - Output:
schema-08.jsonwithvariants(max 2: Primary + Challenger). Each variant is a folder:index.html(shell, loads sections in exact order)section/(one.htmlper section fromrecommended_section_order)img/(image assets)style.css(shared styles, optional)
- Constraints: No JavaScript. No
js/folder. No frameworks. Tailwind CSS via CDN. Mobile-responsive (min 320px). Google Fonts (Inter default). - Progressive disclosure enforced: Hook → Desire → Trust → Objection → CTA.
- Scroll retention: sticky CTA after hero, visual rhythm, open loops.
- Persuasion completeness mapping: every CRO plan field has a visual execution rule.
Promised outcome: Two live, responsive, persuasion-engineered landing page variants ready to deploy. Not a template. Not a wireframe. A finished page.
Scope: Validate every step against its schema, its upstream data, and a red-team checklist (fake scarcity detection, missing BPOM/disclaimer, schema compliance, confidence thresholds).
Technical detail:
- Input: all artifacts
00–08. - Output:
schema-09.jsonwithstep_audits(min 8 steps),overall_status,fix_recommendations,red_team_findings. - Each step audited:
schema_compliant,confidence_pass,completeness,issues,red_team_findings. - Overall status:
PASS,NEEDS_FIX, orFAIL. - Lite mode (
agent-09-lite): reads pre-compressedaudit-input.json(~5 KB) instead of full 118 KB artifacts, for batch runs. - If
FAIL, pipeline halts. IfNEEDS_FIX, fixes are applied and re-audited (max 2 loops).
Promised outcome: You ship with confidence. No fake scarcity. No missing disclaimers. No broken schema. No hand-waving.
┌─────────────────────────────────────────────────────┐
│ Brief (Text/Markdown) │
└────────────┬────────────────────────────────────────┘
│
┌────────────▼────────────────────────────────────────┐
│ Pipeline Orchestrator (pipeline.yaml) │
│ - Max 2 retry loops per step │
│ - Auto-jalan checkpoint (auto-proceed) │
│ - Artifact validation after every step │
└────────────┬────────────────────────────────────────┘
│
┌────────────▼────────────────────────────────────────┐
│ Step 01 → 02 → 03 → 04 → 05 → 06 → 07 → 08 → 09 │
│ Each step: Agent reads prior JSON, writes new JSON │
│ No human-in-the-loop between steps (auto mode) │
└────────────┬────────────────────────────────────────┘
│
┌────────────▼────────────────────────────────────────┐
│ Final deliverables: │
│ - 09-qa/qa-report.json (PASS / FAIL) │
│ - 08-lp/primary/ (live HTML) │
│ - 08-lp/challenger/ (live HTML) │
│ - 07-cro/plans/ (archive plans for future use) │
└─────────────────────────────────────────────────────┘
Every step produces a JSON artifact validated against a strict JSON Schema (Draft-07). This is not documentation — it is the contract between agents.
schemas/schema-01.jsonthroughschema-09.jsondefine the exact shape, required fields, and min/max constraints.schemas/schema-09-lite.jsondefines the lightweight QA contract for batch mode.- If an agent output fails schema validation, the orchestrator retries the step (max 2 times).
- If it still fails, the pipeline halts and logs the error.
Why this matters: Agents don't read paragraphs. They read structured data. The pipeline is deterministic because every step's input is the previous step's output.
performance-ngegas/
├── agents/ # Agent definitions (YAML: name, role, system_prompt, inputs, outputs)
│ ├── agent-01.yml # Target Market Analyst
│ ├── agent-02.yml # JTBD Researcher
│ ├── agent-03.yml # JTBD Deep Map v2
│ ├── agent-04.yml # Role Profiler
│ ├── agent-05.yml # Motivation Database Builder
│ ├── agent-06a.yml # Opportunity Analyst (Variant A)
│ ├── agent-06b.yml # Opportunity Analyst (Variant B)
│ ├── agent-06c.yml # Opportunity Analyst (Variant C — Principal)
│ ├── agent-07.yml # CRO Strategist
│ ├── agent-08.yml # LP Builder
│ ├── agent-09.yml # QA & Red Team Auditor
│ └── agent-09-lite.yml # QA Lite (Batch Mode)
├── prompts/ # Full prompts for each step (Markdown)
│ ├── 01-target-market-analysis.md
│ ├── 02-jtbd-deep-analysis.md
│ ├── 03-jtbd-deep-analysis-v2.md
│ ├── 04-role-profile.md
│ ├── 05-customer-motivation-database.md
│ ├── 06-strategic-opportunity.md
│ ├── 07-cro-plan.md
│ └── 08-landing-page-builder.md
├── schemas/ # JSON Schema contracts (Draft-07)
│ ├── schema-01.json # Target Market Analysis
│ ├── schema-02.json # JTBD Analysis
│ ├── schema-03.json # JTBD v2
│ ├── schema-04.json # Role Profile
│ ├── schema-05.json # Customer Motivation Database
│ ├── schema-06.json # Strategic Opportunity
│ ├── schema-07.json # CRO Plan
│ ├── schema-08.json # Landing Page Implementation
│ ├── schema-08-qa.json # QA metadata for LP
│ ├── schema-09.json # QA Final Report
│ └── schema-09-lite.json# QA Lite Report
├── references/ # Methodology docs, run patterns, troubleshooting
│ ├── methodology.md
│ ├── pipeline-orchestration.md
│ ├── run-patterns.md
│ ├── brief-validator.md
│ ├── landing-page-constraints.md
│ ├── qa-step-09-optimization.md
│ └── ...
├── scripts/ # Execution helpers
│ ├── run.py # Main entry point
│ ├── cro-plan-health-check.py
│ ├── generate-audit-input.py
│ └── qa-script.py
├── .planning/ # Project planning & requirements
│ ├── PROJECT.md
│ ├── REQUIREMENTS.md
│ └── ROADMAP.md
├── pipeline.yaml # Pipeline orchestration config
└── SKILL.md # Hermes Agent skill manifest
Typical run from a founder's brief:
User: "I sell a cold-pressed juice subscription for busy professionals in Jakarta.
Target: 25-40, health-conscious, time-poor, skeptical of 'detox' claims.
Constraint: Must comply with BPOM labeling. No fake scarcity."
Hermes: skill: performance-ngegas
Pipeline:
01 → 02 → 03 → 04 → 05 → 06 → 07 → 08 → 09
Deliverables:
- 08-lp/primary/index.html (Hero: "Capek Terus? Bukan Kurang Tidur")
- 08-lp/challenger/index.html (Hero: "3 Hari Tanpa Kafein = Lebih Fokus")
- 07-cro/plans/plan-archive.json (for future Ramadan campaign)
- 09-qa/qa-report.json (PASS, 0 red-team findings)
Step-by-step:
-
Load the skill:
skill: performance-ngegas -
Provide a brief: Paste your product/service brief as text. Include:
- Product description
- Target audience hint (even if rough)
- Any constraints (regulatory, brand, technical)
-
Run: The orchestrator (
pipeline.yaml) dispatches agents sequentially. Each agent reads the prior JSON artifact and writes the next one. -
Review the CRO plan: Before the build starts, read
07-cro/plans/plan-01.json. If the messaging feels off, you can adjust the brief and re-run. The pipeline is fast enough to iterate. -
Receive deliverables:
08-lp/primary/index.html— your live landing page08-lp/challenger/index.html— A/B challenger variant07-cro/plans/— archived CRO plans for future campaigns09-qa/qa-report.json— audit report with confidence scores
-
Deploy: The HTML is static, framework-free, and CDN-ready. Upload to any hosting (Caddy, Vercel, Netlify, S3, or your VPS).
- Schema validation: Every artifact is validated against its JSON Schema before the next step begins.
- Confidence scoring: Every agent assigns confidence scores. If any step drops below threshold, the orchestrator flags it.
- Red team audit: Step 09 checks for fake scarcity (Math.random, countdown scripts, fake stock), missing regulatory disclaimers (BPOM, etc.), and schema compliance.
- Max retries: 2 loops per step. If still failing, pipeline halts — no broken output ships.
- No JS bloat: Step 08 produces static HTML. No frameworks, no tracking scripts, no unnecessary JS.
- Audit trail: Every artifact includes
metadatawithtimestamp,agent,brief_hash, andpipeline_version.
| Instead of... | You get... |
|---|---|
| A "nice-looking" landing page | A persuasion-engineered page with proven section order and messaging hierarchy |
| Copy based on guesswork | Copy derived from real buyer pain, fear, desire, and daily language |
| One-size-fits-all strategy | Multiple scored CRO plans (Primary + Challenger + Archive) |
| Weeks of back-and-forth | A complete pipeline from brief to live page in hours |
| Unvalidated assumptions | Every insight scored, sourced, and traceable to prior research |
| Fake scarcity / compliance risk | Red-team audit catches it before you ship |
To set honest expectations, here is what the pipeline explicitly does not do:
| Anti-Pattern | Why It's Excluded |
|---|---|
| Inventing data | Every insight must be traceable to a prior artifact. If the research is thin, the output is flagged as Assumption — not fact. |
| One-size-fits-all copy | The pipeline builds variants based on the CRO plan. If the plan says two audiences need different hooks, you get two pages. |
| Fake urgency / dark patterns | Red-team audit (Step 09) scans for Math.random, fake countdowns, and fabricated stock numbers. If found, the pipeline fails. |
| Custom backend logic | The output is static HTML. No payment processing, no user auth, no database. Integrate with your own backend or use a form handler. |
| SEO blog content | This is a landing page pipeline, not a content marketing engine. The focus is conversion, not organic search volume. |
| Infinite revision loops | Max 2 retries per step. If it still fails, the pipeline halts. We ship when it's good, not when it's perfect. |
- Full project planning, requirements, and roadmap live in
.planning/. - See
.planning/PROJECT.mdfor the origin story and design decisions. - See
.planning/REQUIREMENTS.mdfor functional and non-functional requirements. - See
.planning/ROADMAP.mdfor future phases and milestones.
- No proprietary credentials, API keys, or tokens are included in this repository. This is a methodology and agent-definition repo. You run it with your own LLM API keys and hosting infrastructure.
- No medical, financial, or legal claims. The pipeline produces marketing assets. You are responsible for ensuring compliance with local regulations (BPOM, FDA, advertising standards, etc.) before publishing.
- Performance is not guaranteed. "Conversion-ready" means "built on validated research principles." Actual conversion rates depend on traffic quality, offer strength, market fit, and external factors beyond the pipeline's scope.
Built for solo founders and small teams who want agency-grade results without the agency timeline.