DEV Community: HYUN SOO LEE

How I Built an Automated Korean Saju (四柱) Content Pipeline with Claude Vision + Python

HYUN SOO LEE — Mon, 11 May 2026 08:49:35 +0000

The Problem: Structured Data Trapped in Images

Korean Saju (四柱推命) content is booming. Platforms like Naver, Kakao, and a growing wave of indie astrology apps serve millions of readings per month. But the production bottleneck is brutal: every reading starts with a manse calendar screenshot — a dense image containing the four pillars (年柱/月柱/日柱/時柱), ten-god labels (十星), twelve-stage cycle markers (十二運星), and special stars (神殺) — all rendered as overlapping hanja circles and Korean tags.

If you want to publish that reading as a long-form blog post, a YouTube script, a dev.to technical explainer, or a Naver blog entry, you have to manually re-read the image, re-type the data, and re-format for each channel. For a small team running 20–30 subjects per month, that is a full-time job before any writing starts.

This post documents the pipeline I built to fix that — using Claude Vision for structured extraction, a multi-stage prompt chain for content generation, and channel-specific formatters for final output. The Saju reading for SEVENTEEN member Mingyu (戊土 day master, 1997-04-06, male, unknown birth hour) served as the live QA case for the entire system.

Pipeline Overview

[Input Form Screenshot]
↓
[Claude Vision: Structured Extraction]
↓
[Validation Layer: Pillar Consistency Check]
↓
[Prompt Chain: Analysis Blocks]
↓
[Channel Formatter: dev.to / Naver / YouTube Script]
↓
[QA Gate: Guardrail Checks]
↓
[Published Output]

Five stages. Each stage has a defined input schema, output schema, and failure mode. Let me walk through each.

Stage 1 — Claude Vision Extraction

The manse calendar image ( 02_manse_calendar_complete.png) contains the following data classes:

Subject metadata: name, gender, solar date, lunar date, birth hour
Four pillars: 年柱(丁丑), 月柱(甲辰), 日柱(戊寅), 時柱(戊午) — each with hanja characters rendered inside colored circles
Ten-god labels per pillar: 年柱 = 正印(정인) / 劫財(겁재), 月柱 = 偏官(편관) / 比肩(비견), 日柱 = 比肩(비견) / 偏官(편관), 時柱 = 比肩(비견) / 正印(정인)
Twelve-stage cycle markers: 時柱 = 帝旺(제왕), 日柱 = 長生(장생), 月柱 = 冠帶(관대), 年柱 = 養(양)
Special stars (神殺): 年柱 천을귀인(天乙貴人), 백호살(白虎殺), 화개살(華蓋殺); 月柱 백호살(白虎殺); 時柱 양인살(羊刃殺), 도화살(桃花殺); 日柱 편관(장생)
Current Daewoon (大運): 庚子(경자) — 天干庚 = 食神(식신), 地支子 = 正財(정재)
2026 Sewoon (歲運): 丙午(병오) — age 30, 天干丙 = 食神(식신) marker visible, 地支午 = 正財(정재) marker visible

The extraction prompt is a single-shot structured JSON request:

Extract ALL visible hanja characters, Korean ten-god labels,
twelve-stage cycle names, and special star names from this
manse calendar image. Return as JSON with keys:
subject, four_pillars, daewoon, sewoon.
Do NOT infer. Only extract what is visually present.
Flag any character you are less than 90% confident about.

Key engineering decision: the Flag uncertainty instruction. Without it, Claude will confidently hallucinate a ten-god label for a pillar where the image is partially obscured. In the Mingyu test case, the birth hour was unknown (모름), so the 時柱天干 ten-god label was rendered with a placeholder — the extractor correctly flagged this rather than guessing.

Stage 2 — Validation Layer

Before any content generation runs, a Python validation script checks internal consistency:

def validate_pillars(extracted: dict) -> list[str]:
errors = []
# Day master must appear in day pillar heavenly stem
if extracted["day_pillar"]["stem"] != extracted["day_master"]:
errors.append("Day master mismatch")
# Ten-god labels must be consistent with day master
# (simplified: check Friend/比肩 only appears when stem == day master element)
for pillar in ["year", "month", "hour"]:
stem = extracted[pillar]["stem"]
label = extracted[pillar]["stem_god"]
if not ten_god_consistent(extracted["day_master"], stem, label):
errors.append(f"{pillar} stem ten-god inconsistent: {stem} / {label}")
return errors

In the Mingyu case, the validation caught one edge case: the 2026 Sewoon image shows 庚子 in the Daewoon column and 丙午 in the Sewoon column, but the ten-god markers in the Sewoon column are rendered at a smaller font size and partially overlap the Daewoon column. The extractor initially assigned 食神(식신) to 丙 relative to the 庚 Daewoon stem rather than relative to the 戊 day master. The validator caught the mismatch and re-ran the extraction with an explicit anchor instruction: always compute ten-god labels relative to the day master stem (日干), not relative to the Daewoon stem.

This is the single most common error in automated Saju extraction. Build the check before you build anything else.

Stage 3 — Prompt Chain: Analysis Blocks

Once the structured JSON is validated, the content generation runs as a sequential block chain, not a single mega-prompt. Each block receives the validated JSON plus the output of the previous block as context.

Block	Input	Output
Core structure analysis	Four pillars JSON	Five-element ratio, body strength (身强/身弱), yongshin (用神)
Daewoon × Sewoon interaction	Above + Daewoon/Sewoon JSON	Clash (冲), combination (合), ten-god activation summary
Domain readings	Above + domain list	Career, wealth, relationships, health — each 150–200 tokens
Risk signals	Above	2–3 specific risk patterns with structural basis
Quarterly strategy	All above	Q1–Q4 action framing

The Mingyu pipeline produced the following core structural read: 戊土(무토) day master, 土 at 50% of the five-element distribution, 木 25%, 火 25%, 金·水 at 0%. Strong body (身强) structure. 金·水 is the practical yongshin (用神) because 食傷 and 財星 are absent from the main stems and branch primary qi. The current Daewoon 庚子 brings 金·水 energy — structurally favorable — but the 2026 Sewoon 丙午 adds 火·印星 energy that reinforces the already-heavy 土, requiring output regulation rather than expansion.

The key prompt engineering rule here: each block prompt ends with Return only the analysis for this block. Do not summarize previous blocks. Do not add caveats not supported by the extracted data. This keeps token usage predictable and prevents the model from hallucinating structural details it did not extract.

Stage 4 — Channel Formatter

The same analysis JSON feeds three formatters in parallel:

dev.to formatter (this article): technical framing, English, markdown headers, code blocks for pipeline logic, manse calendar data cited as structured input rather than mystical oracle.

Naver Blog formatter: Korean, conversational tone, HTML-compatible line breaks, domain-specific vocabulary (운세, 사주, 대운), no code blocks, CTA pointing to the full reading platform.

YouTube Script formatter: spoken Korean, 8–12 minute target length, hook in first 30 seconds referencing the specific structural pattern (e.g., "土가 절반인 사주에서 2026년에 무슨 일이 생기는지"), chapter markers at each domain block.

Each formatter has a channel-specific guardrail list appended to the system prompt:

GUARDRAILS (dev.to):

No fortune-telling framing
No certainty language (must/will/definitely)
No privacy speculation
Cite image source for all data claims
CTA = runartree.com

Stage 5 — QA Gate

Before any output is published, an automated QA pass checks:

Certainty language scan: regex for "반드시", "무조건", "절대", "확실히", "will definitely", "guaranteed" — any match blocks publication
Data consistency check: every hanja character in the output must appear in the validated extraction JSON — no hallucinated pillars
Tone check: sentiment classifier flags outputs that score above threshold on anxiety-inducing language
Word count gate: channel-specific minimum/maximum
CTA presence: output must contain the CTA URL exactly once

The Mingyu test case passed all five gates on the second run. The first run failed the certainty language scan because the career block used the phrase "성과가 반드시 쌓입니다" — caught, revised to "성과가 쌓이는 흐름입니다."

[INFO_GRAPHIC] Mingyu 2026 — Structural Snapshot

Day Master: 戊土 (Strong Earth) | Body Strength: 身强
Five Elements: 土50% / 木25% / 火25% / 金·水 0%
Yongshin (用神): 金·Water

四柱 (Four Pillars):
年柱: 丁(天乙貴人·白虎殺·華蓋殺) / 丑(劫財·養)
月柱: 甲(偏官·★) / 辰(比肩·冠帶·白虎殺)
日柱: 戊 / 寅(偏官·長生)
時柱: 戊(比肩·羊刃殺·桃花殺) / 午(正印·帝旺)

Daewoon: 庚子 | 食神 / 正財 | 子↔午冲, 子↔丑合
2026 Sewoon: 丙午 | 偏印 / 正印 | 午+午 double-trigger

Score: 68/100 | Flow: Upper-Mid

The Reversal: 天乙貴人 in 年支

The structural story of this chart is heavy 土, absent 金·Water, strong body — sounds like a closed, self-sufficient system that resists external input. That reading is mostly correct. But the 年支丑(축) carries 天乙貴人(Heavenly Noble Star), which is the single most reliable "unexpected door opens" marker in classical Saju.

Zi Ping Zhen Quan (子平真詮, Chapter on Useful Gods) notes that 貴人 stars activate most visibly when the chart is otherwise under pressure — precisely the condition created by the 子↔午 clash in the current Daewoon. The practical pipeline implication: the QA system flags 天乙貴人 as a positive anomaly that must appear in the output, because omitting it would produce a structurally incomplete and tonally misleading read.

Lessons Learned

1. Anchor ten-god labels to the day master, always. The most common extraction error. Build the validator before the generator.

2. Block-chain prompts outperform single mega-prompts. Smaller, sequential blocks produce more consistent structural logic and are easier to QA.

3. Unknown birth hour is not a blocker. The 時柱 is flagged as uncertain, the analysis runs on the remaining three pillars, and the output notes the limitation explicitly. Do not hallucinate a birth hour.

4. Channel formatters need their own guardrail lists. What is appropriate framing for a technical dev.to post is wrong for a Naver Blog post aimed at a general Korean audience, and vice versa.

5. The 午↔午 double-trigger is a real extraction challenge. When the 時柱地支 and the 2026 Sewoon 地支 are identical (both 午), some extractors collapse them into a single entry. The validator must check for this explicitly.

Summary

Claude Vision extracts structured four-pillar data from manse calendar screenshots; validation anchors all ten-god labels to the day master stem before any content generation runs
A sequential block-chain prompt architecture produces domain-specific analysis (career, wealth, relationships, health) with traceable structural basis — for Mingyu's 戊土 chart, the 2026 丙午 Sewoon adds 火·印星 pressure to an already 土-heavy structure, making output regulation the core strategic frame
Channel-specific formatters and a five-gate QA pass convert the same validated JSON into dev.to, Naver Blog, and YouTube Script outputs without manual reformatting

Want to explore this pipeline or run a reading for your own chart?
Full manse calendar generation, structured analysis, and long-form content output are available at runartree.com.

This article uses a published Saju reading as a technical test case for pipeline documentation purposes. Saju analysis reflects structural pattern interpretation based on classical Chinese metaphysics and does not constitute prediction, guarantee, or professional advice of any kind. All outputs should be read as probabilistic framing, not certainty.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

Building an Automated Saju (Korean Bazi) Content Pipeline: Vision Extraction, Channel Formatting, and QA at Scale

HYUN SOO LEE — Sun, 10 May 2026 00:00:05 +0000

The Problem: Manual Saju Content Doesn't Scale

Korean Saju (四柱, Four Pillars of Destiny) content is exploding across YouTube, blogs, and short-form video. The demand is real. The bottleneck is equally real: every piece of content requires a human practitioner to read a manse (萬歲曆, traditional calendar chart), extract structured data — Day Pillar (日柱), Ten Gods (十星), 12-phase cycle (十二運星), auspicious and inauspicious spirits (神殺) — and then rewrite that data into channel-appropriate copy.

For a single subject like a 2026 annual reading, a practitioner might produce:

A long-form YouTube script (~2,500 words)
A blog post (~1,500 words)
A short-form vertical video script (~300 words)
A dev-facing technical breakdown (this article)

Doing that manually for every content subject, every year, every channel, is a full-time job. This post documents the automation pipeline we built at Runartree to solve it.

What the Pipeline Actually Does

The pipeline takes two inputs:

Screenshot images — manse calendar renders, input confirmation screens, and long-form result pages exported from our Saju web app
A structured content brief — subject name, trigger date, topic, channel target, word count, required content blocks

It outputs channel-formatted markdown or script copy, validated against a QA checklist before it ever reaches a human editor.

Here is the high-level flow:

[Screenshot images] → [Claude Vision extraction] → [Structured JSON]
↓
[Prompt assembly] → [Claude generation] → [Raw markdown]
↓
[QA checks] → [Channel formatter] → [Final output]

Stage 1: Vision Extraction

The hardest part of the pipeline is not generation — it is reliable structured extraction from manse calendar screenshots.

A typical manse image (see 02_manse_calendar_complete.png in our test set) contains:

Four pillars arranged in columns: 時柱 (Hour), 日柱 (Day), 月柱 (Month), 年柱 (Year)
Each pillar has: Heavenly Stem (天干) hanja glyph, Earthly Branch (地支) hanja glyph, Ten God label in Korean hangul, 12-phase label in Korean hangul
Auspicious/inauspicious spirit tags rendered as colored badge chips below each pillar
A separate column for the current Grand Luck Cycle (大運) and Annual Luck (歲運)

The extraction prompt we use is structured as a two-pass system.

Pass 1 — Raw OCR with position anchoring:

You are a manse calendar OCR engine.
For each of the six columns (Hour, Day, Month, Year, Grand Luck, Annual Luck):
Extract: heavenly stem hanja, earthly branch hanja,
heavenly stem ten-god label (Korean, verbatim),
earthly branch ten-god label (Korean, verbatim),
12-phase label (Korean, verbatim),
all spirit/神殺 badge labels (Korean, verbatim, with column position).
Return as JSON. Do not translate or interpret. Copy text exactly as rendered.

Pass 2 — Verification cross-check:

We re-send the image with the Pass 1 JSON and ask Claude to flag any field where the extracted hanja does not match the visible glyph. This catches common OCR errors like 壬/王 confusion or 己/已 confusion — both of which appear in real manse images.

For the test subject in this pipeline run (양력 1996년 1월 16일, 여성, 모름시), the verified extraction produced:

年柱: 乙亥 — 上官(상관) / 比肩(비견)
月柱: 己丑 — 正官(정관) / 正官(정관)
日柱: 壬子 — [日主] / 劫財(겁재)
時柱: 丙午 — 偏財(편재) / 正財(정재)
Grand Luck (大運): 壬辰 — 比肩(비견) / 偏官(편관)
Annual Luck 2026 (歲運): 丙午 — 偏財(편재) / 正財(정재)

Extracted 神殺 included: 天醫星(천의성) on Day Branch, 羊刃殺(양인살) on multiple pillars, 鬼門關殺(귀문관살) on Month Branch and Hour Branch, 桃花殺(도화살) on Day Branch, 帝旺(제왕) phase on Day Branch.

One critical guard in the extraction prompt: verbatim label preservation. If the image renders 正財 on the Hour Branch heavenly stem, the JSON must say 正財 — not 偏財, not "wealth star." Downstream generation prompts are built on this JSON, and a single mislabeled Ten God corrupts the entire interpretation chain.

Stage 2: Structured JSON Schema

After extraction, we normalize into a typed schema:

@dataclass
class Pillar:
position: str # "year" | "month" | "day" | "hour"
stem_hanja: str # e.g. "壬"
branch_hanja: str # e.g. "子"
stem_ten_god: str # verbatim Korean label
branch_ten_god: str # verbatim Korean label
twelve_phase: str # verbatim Korean label
spirits: list[str] # verbatim Korean badge labels

@dataclass
class ManseChart:
subject_name: str
gender: str
solar_date: str
lunar_date: str
pillars: list[Pillar] # year, month, day, hour
grand_luck: Pillar
annual_luck: Pillar
body_strength: str # "신강" | "신약"
element_ratio: dict # {"水": 40, "火": 25, "土": 25, ...}

This schema is serialized to JSON and passed directly into generation prompts. No free-text interpretation at this stage. The schema enforces that generation prompts receive only what the image actually contained.

Stage 3: Prompt Strategy for Long-Form Generation

Long-form Saju content has a specific structure that readers expect. We encode this as a required block manifest in the generation prompt:

Required blocks (in order):

Hook — 3 lines, reference one specific chart element
One-line conclusion — Day Pillar + dominant Ten God + 2026 Annual Luck
Bazi principles — cite at least 3 elements: stems, branches, Ten Gods, spirits
Classical reference — one line from 滴天髓/子平真詮/窮通寶鑑/淵海子平 with source
Modern interpretation — connect Annual Luck and Grand Luck to subject's domain
Infographic placeholder — [INFO_GRAPHIC] tag
Reversal insight — one unexpected interaction (spirit, combination, clash)
Three-line summary
CTA — runartree.com

The generation prompt also carries a guardrail block:

Guardrails:

No speculation beyond the extracted chart
No absolute certainty language (100%, definitely, certainly, guaranteed)
No gossip or personal life assertions
Disclaimer line required at end
Use English + hanja notation for all technical terms

This guardrail block is checked post-generation by a separate QA pass (Stage 5).

Stage 4: Channel Formatting

The same structured JSON and the same generation output get reformatted per channel. The formatter is a simple Python class with per-channel render methods:

class ChannelFormatter:
def render_devto(self, content: GeneratedContent) -> str:
# YAML frontmatter + dev.to markdown
# Technical framing: pipeline, not fortune-telling
...

def render_blog(self, content: GeneratedContent) -> str:
    # Korean-language long-form
    # Dalbitnaemu tone guidelines applied
    ...

def render_shorts_script(self, content: GeneratedContent) -> str:
    # 300-word vertical video script
    # Hook in first 3 seconds, single CTA
    ...

Channel-specific rules are encoded as formatter config, not baked into the generation prompt. This means the same generation output can be reformatted without re-running the expensive Vision + generation steps.

For dev.to specifically, the formatter:

Strips all Korean hangul from body text
Converts Ten God labels to English + hanja format: Direct Wealth(正財), Indirect Wealth(偏財), etc.
Ensures frontmatter tags include bazi, kpop, saju, korea
Inserts the [INFO_GRAPHIC] block as a placeholder comment for the design team

Stage 5: QA Checks

Before any output reaches a human editor, it runs through an automated QA checklist:

Check	Method
Required blocks present	Regex scan for block headers
Ten God labels match extracted JSON	String diff against schema
Guardrail violations	Claude classification pass
Word count within ±10% of target	`len(content.split())`
Hanja notation format consistent	Regex: `[A-Za-z]+\([^\)]+\)`
No Korean hangul in English-channel output	Unicode range check `\uAC00-\uD7A3`
CTA present	String search for `runartree.com`
Disclaimer present	String search for disclaimer pattern

The guardrail violation check deserves special mention. We send the generated text back to Claude with a focused classification prompt:

Does this text contain any of the following? Answer YES/NO for each:

Absolute certainty language (must, will definitely, 100%)
Personal life speculation beyond the chart
Anxiety-inducing predictions without mitigation
Missing disclaimer

If any answer is YES, the output is flagged for human review rather than auto-published.

[INFO_GRAPHIC]

Suggested asset: A four-column pillar diagram showing 壬子 Day Pillar at center, 丙午 Annual Luck 2026 on the right, with a red clash arrow between 子 and 午 branches, and a blue reinforcement arrow between 壬 Grand Luck stem and 壬 Day Stem. Labels in English + hanja. Brand colors: Runartree dark navy + gold.

The Reversal: The Hour Pillar Clash Is Already in the Chart

Here is the part that surprises most people who look at this chart for the first time.

The 2026 Annual Luck pillar is 丙午. The Hour Pillar (時柱) of the natal chart is also 丙午 — identical heavenly stem and earthly branch. This means the Annual Luck is not introducing a new energy into the chart: it is doubling an energy that already exists natively.

When 午(오) appears in both the Hour Branch and the Annual Luck simultaneously, the clash between 午 and the Day Branch 子 is not a single external pressure — it is a resonance effect. The chart's own Hour Pillar amplifies the Annual Luck's clash against the Day Branch. In classical terms this is called 伏吟(복음), a "hidden echo," and it tends to intensify both the opportunity signal (Direct Wealth 正財 activating strongly) and the instability signal (子午沖 destabilizing the daily rhythm) beyond what either factor would produce alone.

This is why the QA-flagged interpretation for this chart emphasizes energy management over opportunity chasing. The Direct Wealth(正財) and Indirect Wealth(偏財) signals are genuinely strong — but the structural amplification means the cost of overextension is also amplified.

Lessons Learned

1. Verbatim extraction is non-negotiable. The single most common failure mode in early pipeline versions was the model "correcting" a Ten God label based on its own interpretation rather than copying the image text. A 正財 relabeled as 偏財 produces a fundamentally different interpretation. Solve this with explicit verbatim instructions and a verification pass.

2. Schema before generation. Passing structured JSON to the generation prompt produces dramatically more consistent output than passing image descriptions. The schema enforces boundaries. Free-text descriptions invite hallucination.

3. Channel formatting is cheap; re-generation is expensive. Invest in the formatter layer. A single generation run should feed multiple channels. Re-running Vision + generation because a channel format was wrong is a waste of API budget.

4. QA catches what prompts miss. Even well-crafted generation prompts occasionally produce guardrail violations. The automated QA pass is not optional — it is the last line before human review.

5. The disclaimer is load-bearing. In Saju content, the disclaimer is not boilerplate. It is the structural element that separates a content automation pipeline from a prediction service. Every output, every channel, every time.

Summary

Claude Vision + structured JSON extraction is reliable for manse calendar screenshots when verbatim extraction is enforced and a verification pass is included
Required block manifests and guardrail blocks in generation prompts produce consistent, channel-appropriate long-form content
Per-channel formatters decouple generation from presentation, reducing API costs significantly
Automated QA on block presence, Ten God label consistency, guardrail violations, and word count catches the majority of output failures before human review

Try the Pipeline Output

The Saju content automation pipeline described in this article powers the readings at runartree.com. If you are building content automation in a specialized domain — astrology, numerology, TCM, or any knowledge-dense vertical — the extraction-schema-generation-QA pattern transfers directly.

This article describes a content generation pipeline and uses a publicly known public figure's birth data as a technical test case for chart extraction accuracy. All interpretations are generated outputs for pipeline demonstration purposes only. Saju readings are a traditional cultural reference framework and do not constitute predictions, advice, or guaranteed outcomes of any kind.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

How We Built an Automated Korean Saju Content Pipeline with Claude Vision + Python

HYUN SOO LEE — Sat, 09 May 2026 11:10:30 +0000

How We Built an Automated Korean Saju Content Pipeline with Claude Vision + Python

The Problem: Longform Content at Scale, Without Losing Precision

Korean Saju (四柱, Four Pillars of Destiny) content is structurally rich — each reading contains a natal chart (원국), a current major cycle (대운), an annual cycle (세운), and layered interpretations across career, wealth, relationships, and health. A single public-figure reading can run 3,000–5,000 Korean words, with dozens of named variables: Heavenly Stems (天干), Earthly Branches (地支), Ten Gods (十星), and classical star markers like Heavenly Noble (天乙貴人) or Peach Blossom (桃花殺).

The manual workflow looked like this: a senior analyst runs the chart → captures screenshots → writes interpretation → editor formats per channel → QA checks for factual drift. That pipeline took 4–6 hours per reading, per channel.

Our goal: reduce that to under 45 minutes of human time, with zero factual hallucination on the chart data.

The Architecture: Four Stages

[Manse Calendar UI]
→ [Claude Vision Extraction]
→ [Prompt Chain Interpretation]
→ [Channel Formatter]
→ [QA Gate]
→ [Publish]

Each stage has a distinct responsibility and a distinct failure mode. We'll walk through each.

Stage 1 — Vision Extraction: Reading the Chart Image

The Manse calendar (만세력) is rendered as a UI screenshot, not a structured data export. That means the ground truth for every reading lives in an image.

We feed four screenshot types into Claude Vision:

Image	Content
`01_input_confirm.png`	Name, gender, solar date, birth hour
`02_manse_calendar_complete.png`	Full four-pillar grid with Ten Gods, 12-phase markers, star markers
`03–06_total_luck_N.png`	Longform interpretation scroll captures

The extraction prompt is strict and non-inferential:

Extract exactly what is visible in the image.
Do not infer, translate, or rephrase any character or label.
If the Hour Pillar Heavenly Stem Ten God reads "正財" (Direct Wealth),
output "正財". Do not substitute "偏財".
Output as structured JSON with keys:
name, gender, solar_date, lunar_date, birth_hour,
pillars: { year, month, day, hour } each containing
{ stem, branch, stem_god, branch_god, twelve_phase, star_markers[] },
current_daewoon: { stem, branch, stem_god, branch_god },
annual_cycle_2026: { stem, branch, stem_god, branch_god, star_markers[] }

Why this matters: In our live case — Kang Daniel (강다니엘), male, solar 1996-12-10, birth hour unknown — the Hour Pillar (時柱) Heavenly Stem is 甲 with Ten God label 正財 (Direct Wealth, 정재). An early prompt version that said "identify the Ten God" without the non-substitution guard produced 偏財 (Indirect Wealth) because the model pattern-matched on 甲 relative to 辛 and computed independently. The guard clause eliminated that class of error entirely.

Extracted ground truth (live case):

Day Pillar (日柱): 辛(신) / 巳(사) — Ten Gods: 比肩(비견) / 正官(정관)
Month Pillar (月柱): 庚(경) / 子(자) — Ten Gods: 劫財(겁재) / 食神(식신)
Year Pillar (年柱): 丙(병) / 子(자) — Ten Gods: 正官(정관) / 食神(식신)
Hour Pillar (時柱): 甲(갑) / 午(오) — Ten Gods: 正財(정재) / 偏官(편관)
Current Daewoon: 甲辰(갑진) — 正財(정재) / [辰子 semi-combination, Water reinforcement]
2026 Annual Cycle: 丙午(병오) — 正官(정관) / 偏官(편관)
Star markers extracted: 天乙貴人(천을귀인) at Hour Branch 午, 天德貴人(천덕귀인) at Hour Branch 午, 암록(暗祿) at Month Pillar

Stage 2 — Prompt Chain: Interpretation Without Hallucination

Once the JSON is clean, we run a four-prompt chain. Each prompt receives only the JSON output of the previous stage plus a scoped instruction. No prompt sees the raw image again after Stage 1.

Prompt 1 — Structure Summary

Given this chart JSON, summarize the structural profile:

Day Master strength (身强/身弱)
Dominant element distribution
Ten God concentration (how many 官星, 食傷, 財星, 印星, 比劫)
Key tensions (충/沖, 합/合, 형/刑 between pillars) Output: structured summary, no prose yet.

For Kang Daniel: Day Master 辛金 is 身弱 (weak) — three 官星 (正官×2 + 偏官×1), two 食傷 (食神×2), zero 印星 in Heavenly Stems. Fire element at ~40%, Water ~30%, Metal ~20%, Wood ~10%, Earth ~0%. Critical tension: 子午沖 (子 in Year/Month Branch vs 午 in Hour Branch).

Prompt 2 — Domain Interpretation

Each domain (career, wealth, relationships, health) gets a separate sub-prompt with the structural summary as context. This prevents cross-domain contamination and makes QA easier — each block is independently auditable.

Prompt 3 — Annual Cycle Overlay

Given the structural summary and domain interpretations,
overlay the 2026 annual cycle (丙午).
Identify: which existing pillars does 午 interact with?
What does doubling of 官星 (正官 + 偏官) mean for a 身弱 Day Master?
Do not introduce chart elements not present in the JSON.

The 2026 overlay is where the most interesting dynamics surface. 丙午年 means:

Heavenly Stem 丙 = 正官 (Direct Officer) relative to 辛 Day Master
Earthly Branch 午 = 偏官 (Seven Killings) relative to 辛
午 repeats the Hour Branch, reactivating 天乙貴人 — unexpected support signal in a high-pressure year
午 clashes with Year Branch 子 and Month Branch 子 (子午沖×2) — environmental disruption to established routines

Prompt 4 — Channel Formatting

This is where the pipeline branches. The same interpreted content gets reformatted per channel spec. Dev.to gets English technical framing. A YouTube script gets a different cadence. A blog post gets Korean prose. The interpretation JSON is the single source of truth; formatting is downstream.

Stage 3 — Channel Formatter

Each channel has a spec file that the formatter reads:

CHANNEL_SPECS = {
"devto": {
"language": "en",
"format": "markdown",
"tone": "technical_analytical",
"word_target": 1500,
"forbidden": ["fortune_telling_framing", "certainty_language", "gossip"],
"required_blocks": [
"hook", "conclusion_one_liner", "bazi_mechanics",
"classical_citation", "modern_application",
"infographic_placeholder", "reversal_insight",
"summary_three_lines", "cta"
]
},
"youtube_script": { ... },
"blog_ko": { ... }
}

The formatter prompt receives the interpretation JSON plus the channel spec and produces the final draft. Crucially, it does not re-read the chart — it only formats what the interpretation chain already produced.

[INFO_GRAPHIC]

KANG DANIEL — 辛巳 Day Pillar | 2026 丙午 Annual Cycle

PILLAR GRID
┌──────────┬──────────┬──────────┬──────────┐
│ 時柱 │ 日柱 │ 月柱 │ 年柱 │
│ Hour │ Day │ Month │ Year │
├──────────┼──────────┼──────────┼──────────┤
│ 正財 │ 比肩 │ 劫財 │ 正官 │
│ 甲 Wood │ 辛 Metal│ 庚 Metal│ 丙 Fire │
│ 甲 (갑) │ 辛 (신) │ 庚 (경) │ 丙 (병) │
├──────────┼──────────┼──────────┼──────────┤
│ 偏官 │ 正官 │ 食神 │ 食神 │
│ 午 Fire │ 巳 Fire │ 子 Water│ 子 Water│
│ 午 (오) │ 巳 (사) │ 子 (자) │ 子 (자) │
└──────────┴──────────┴──────────┴──────────┘

STAR MARKERS: 天乙貴人 + 天德貴人 @ 午 (Hour Branch)
KEY TENSION: 子午沖 (Month/Year Branch vs Hour Branch)

2026 OVERLAY: 丙午
Stem 丙 → 正官 (Direct Officer) — opportunity + accountability
Branch 午 → 偏官 (Seven Killings) — pressure layer
午 reactivates 天乙貴人 — hidden support signal
午 triggers 子午沖×2 — routine disruption likely

DAEWOON: 甲辰 | 甲 → 正財 | 辰子 semi-combination (Water+)
BODY STRENGTH: 身弱 | 官星×3 | 食傷×2 | 印星×0 in Stems

Stage 4 — QA Gate

Before any content publishes, it passes through a five-check QA gate:

Check 1 — Character Fidelity
Every Hanja character and Ten God label in the output is compared against the Stage 1 JSON. Any mismatch triggers a block. This is the 正財/偏財 guard at output level.

Check 2 — Certainty Language Scan
A regex + classifier pass flags phrases like "will definitely," "100%," "certain to," "absolutely." These are replaced with hedged equivalents or flagged for human review.

Check 3 — Gossip / Privacy Filter
Any sentence containing relationship-status assertions, health diagnoses, or financial predictions stated as fact is flagged. The filter is trained on a small dataset of problematic examples from early drafts.

Check 4 — Classical Citation Verification
If the interpretation chain inserted a classical text citation, the QA step verifies it matches a pre-approved citation library. Fabricated citations are a known LLM failure mode in this domain.

For reference, a structurally relevant citation for this reading: Zi Ping Zhen Quan (子平真詮, He Lun Qing, Qing Dynasty) discusses the 身弱 Day Master under heavy 官殺 pressure: the remedy is 印星 support; absent that, energy conservation becomes the primary strategic principle. This maps directly to the 2026 reading's core recommendation.

Check 5 — Word Count and Block Completeness
All nine required blocks must be present. Word count must fall within ±10% of target. Missing blocks or overruns trigger a regeneration request for the specific block, not the full piece.

The Reversal: The Star Marker Nobody Expects

The technically interesting finding in this chart — and the one most likely to be missed by a naive extraction — is that 天乙貴人 (Heavenly Noble) sits at the Hour Branch 午, the same branch that 2026's annual cycle repeats.

In a year where 官星 doubles and 子午沖 fires twice, the conventional read is "high pressure, high cost." The reversal: 午 also reactivates the most powerful support star in the chart. The 2026 annual cycle is not purely adversarial — it also lights up the branch where unexpected assistance and key-moment support are structurally encoded.

This is the kind of nuance that disappears if the Vision extraction is imprecise (wrong branch assignment) or if the interpretation chain doesn't cross-reference star markers against the annual cycle overlay. It's also the kind of insight that makes the content genuinely useful rather than generically cautionary.

Lessons Learned

1. Extraction and interpretation must be strictly separated. Any prompt that does both simultaneously will drift. The model will rationalize chart data to fit an interpretation it's already building.

2. Non-substitution guards are not optional. Especially for Ten God labels where the model has strong priors from training data. Explicit negative constraints outperform positive description alone.

3. Channel formatting is the last step, not the first. Early versions tried to format while interpreting. Output quality dropped significantly. Separation of concerns applies here exactly as it does in software architecture.

4. QA is cheaper than correction. A five-check gate that blocks 15% of drafts saves more time than editing published content that contains a factual error about a public figure's chart.

5. Star markers are high-value, low-extraction-rate data. They appear as small colored badges in the UI. Without explicit Vision prompting for badge-level detail, they are systematically missed — and they often contain the most analytically interesting information.

Summary

Automated Saju content pipeline: Vision extraction → prompt chain → channel formatter → QA gate, with strict separation of concerns at each stage
The critical engineering challenge is not generation quality but extraction fidelity — wrong Hanja or wrong Ten God label at Stage 1 propagates through every downstream step
The 2026 reading for this case study surfaces a structurally meaningful reversal (天乙貴人 reactivation in a high-pressure 官星 year) that only appears when star marker extraction is precise and cross-referenced against the annual cycle overlay

Explore the full Saju content platform and automated reading tools at runartree.com

This article uses publicly available birth information and a published Saju reading as a technical case study for content pipeline automation. All interpretations reflect classical Bazi analytical frameworks and are presented as structural analysis, not predictive certainty. Individual outcomes vary and no reading should be treated as a definitive forecast.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

How I Built an Automated Korean Saju Content Pipeline with Claude Vision and Python

HYUN SOO LEE — Fri, 08 May 2026 08:39:29 +0000

How I Built an Automated Korean Saju Content Pipeline with Claude Vision and Python

TL;DR: I needed to produce structured, channel-specific long-form content about Korean Saju (四柱推命) at scale. Instead of manually reading manse calendar screenshots and writing drafts by hand, I built a Python pipeline that ingests calendar images, extracts structured pillar data via Claude Vision, runs a multi-stage prompt chain, enforces channel formatting rules, and passes output through a QA gate before publishing. Here is exactly how it works.

1. The Problem

Korean Saju content — destiny analysis based on the Four Pillars of Birth (年柱·月柱·日柱·時柱) — is inherently data-dense. A single reading involves:

Six data columns (year, month, day, hour, current major cycle, annual cycle) each carrying a Heavenly Stem (天干), Earthly Branch (地支), a Ten-God relationship (十星), a 12-Phase life stage (十二運星), and one or more auspicious/inauspicious markers (神殺).
Derived structural judgments — chart strength (身强/身弱), dominant element distribution, repeating branch patterns (e.g., 午午午 triple resonance across day branch, hour branch, and annual branch).
Channel-specific tone — a dev.to audience wants technical framing; a YouTube audience wants narrative; a Naver Blog audience wants bullet-point summaries with score tables.

Doing this manually meant: open the manse calendar app, screenshot six columns, re-read every glyph, write a 1500-word draft, reformat for the target channel, QA for factual consistency, then publish. For one subject that takes roughly three hours. At any meaningful content volume, that is not viable.

The goal: reduce human time-on-task to prompt review + final approval, with the machine handling extraction, structuring, drafting, and format enforcement.

2. Pipeline Overview

[Manse Calendar App]
│
▼
[Screenshot Capture Layer] ← 4–6 PNG files per subject
│
▼
[Claude Vision Extraction] ← Structured JSON: pillars, ten-gods, 12-phase,神殺
│
▼
[Validation & Normalisation] ← Python: cross-check stem/branch consistency
│
▼
[Prompt Chain: Draft Generation] ← Multi-block long-form prompt
│
▼
[Channel Formatter] ← dev.to / YouTube script / Naver Blog
│
▼
[QA Gate] ← Hallucination checks, forbidden phrase scan
│
▼
[Output: Markdown / SRT / HTML]

Each stage is a discrete Python module. Stages are orchestrated by a simple pipeline.py that passes a shared subject_context dict through each step.

3. Screenshot Ingestion and Vision Extraction

The manse calendar app outputs visual data, not an API. That means the entry point is always image files. For a typical subject the capture set looks like this:

File	Content
`01_input_confirm.png`	Name, gender, solar date, birth hour status
`02_manse_calendar_complete.png`	Full four-pillar grid with ten-gods, 12-phase, 神殺 badges
`03_total_luck_1.png` – `06_total_luck_4.png`	Long-form luck analysis text blocks

The Vision extraction prompt is the most critical piece of the entire pipeline. A poorly specified extraction prompt produces plausible-sounding but wrong data — and because Saju analysis is deterministic (given a birth date and gender, every pillar value is fixed), any extraction error propagates as a factual error into every downstream output.

Extraction prompt design principles I learned the hard way:

Ask for exact glyph transcription, not interpretation. The prompt says: "Transcribe the Korean hangul label exactly as it appears in the image. If the image shows 정재, output 정재. Do not substitute 편재." This sounds obvious but early versions of the prompt were silently correcting what the model thought were inconsistencies — e.g., flipping a Direct Wealth (正財) label to Indirect Wealth (偏財) because the stem looked like a 偏財 stem to the model. That is catastrophic for downstream accuracy.
Extract position metadata. The output JSON includes not just the value but where it appears: {"column": "hour", "layer": "ten_god_stem", "value": "편재"}. This lets the validation layer catch cross-column inconsistencies.
Separate extraction from interpretation. The Vision call only extracts. It does not judge chart strength, does not infer relationships between pillars, does not produce prose. That happens in the next stage.

Sample extraction output (simplified):

{
"subject": { "name": "Jang Won-young", "gender": "female", "solar_birth": "2004-08-31", "birth_hour": "unknown" },
"pillars": {
"year": { "stem": "甲", "branch": "申", "stem_ten_god": "식신", "branch_ten_god": "편인", "twelve_phase": "장생", "spirits": ["역마살", "공망"] },
"month": { "stem": "壬", "branch": "申", "stem_ten_god": "비견", "branch_ten_god": "편인", "twelve_phase": "장생", "spirits": ["월덕귀인", "역마살", "공망"] },
"day": { "stem": "壬", "branch": "午", "stem_ten_god": "비견", "branch_ten_god": "정재", "twelve_phase": "태", "spirits": ["원덕귀인"] },
"hour": { "stem": "丙", "branch": "午", "stem_ten_god": "편재", "branch_ten_god": "정재", "twelve_phase": "태", "spirits": ["월공", "양인살"] }
},
"major_cycle": { "stem": "庚", "branch": "午", "stem_ten_god": "편인", "branch_ten_god": "정재", "age": 18 },
"annual_cycle_2026": { "stem": "丙", "branch": "午", "stem_ten_god": "편재", "branch_ten_god": "정재" }
}

4. Validation and Normalisation

Before any prose generation touches this data, a Python validation pass runs three checks:

Check 1 — Stem/branch consistency. Given the day master (日主) stem, every ten-god label is mathematically deterministic. The validator recomputes expected ten-god values from the stem and flags any mismatch between the computed value and the extracted label. If Vision extracted a label that contradicts the stem relationship, the pipeline halts and logs a EXTRACTION_CONFLICT error for human review.

Check 2 — Branch repetition detection. The validator scans all six branch slots (four pillars + major cycle branch + annual cycle branch) and flags any branch that appears three or more times. In this subject's case, 午 appears in day branch, hour branch, major cycle branch, and 2026 annual cycle branch — a four-way resonance that is structurally significant and needs to be called out explicitly in the draft prompt.

Check 3 — Forbidden phrase pre-check. A list of absolute-prohibition strings (["반드시", "확실히", "무조건", "절대", "100%"] and their English equivalents) is checked against any text fields extracted from the long-form image blocks. If found, those segments are flagged for tone adjustment before they enter the draft prompt context.

5. Prompt Strategy for Draft Generation

The draft generation stage uses a structured multi-block prompt. The key design decision is block-level responsibility: each named section of the output is generated with its own instruction context, rather than asking the model to produce everything in one pass.

Block map:

Block	Instruction focus
Hook (3 lines)	Lead with the structurally most surprising fact from the extracted data
One-line thesis	Day master + dominant ten-god + 2026 annual cycle, no hedging
Mechanics section	Cite at least 3 ten-gods or 神殺 with positional context
Classical reference	One line from 滴天髓 / 子平真詮 / 窮通寶鑑 / 淵海子平 with source
Modern application	Map the trigger subject's known public activity domain to the annual cycle
Infographic block	`[INFO_GRAPHIC]` placeholder for the design pipeline to fill
Reversal paragraph	One counter-intuitive finding — a 神殺 or branch combination that cuts against the dominant narrative
3-line summary	Compress the entire reading to three sentences
CTA	Injected by the formatter, not by the draft prompt

The prompt explicitly instructs the model: "You are working from extracted structured data. Do not invent pillar values. Do not infer birth details not present in the extraction JSON. If a field is marked 'unknown' (e.g., birth hour), treat the hour pillar as provided and do not speculate about alternative hour values."

6. Channel Formatter

The same structured draft gets reformatted by a channel-specific formatter module. Each formatter is a Python class with a transform(draft: str, context: dict) -> str method.

dev.to formatter rules:

Output valid Markdown with YAML frontmatter
Tags drawn from a controlled vocabulary (bazi, kpop, saju, korea)
No code fences wrapping the entire document
Hanja terms rendered inline with English gloss: Indirect Wealth(偏財), Goat Blade(羊刃殺)
All Korean hangul stripped from final output; terminology expressed in English + hanja only
Target word count: 1400–1600 words; formatter trims or expands the reversal and mechanics sections to hit range
CTA block appended from a template string, not from the draft

YouTube script formatter rules (different module):

Output plain text with [PAUSE] and [B-ROLL: X] markers
Hangul preserved for on-screen text overlays
Sentences capped at 18 words for teleprompter pacing

7. QA Gate

The QA gate runs after formatting and before any publish call. It is not a model call — it is a deterministic rule engine.

Rules that cause a BLOCK (pipeline halts):

Any ten-god label in the output that contradicts the validation JSON (e.g., output says "Direct Wealth(正財)" in the hour stem position but the JSON says 편재)
Any of the forbidden certainty phrases present in the output
Word count outside ±15% of target
Missing required blocks (checked by scanning for section header strings)

Rules that cause a WARN (logged, human reviews before publish):

Classical reference citation present but source tag missing
Infographic placeholder [INFO_GRAPHIC] not replaced by the design pipeline
Subject name appears in a sentence with a romantic or health-definitive predicate

The QA gate rejects roughly 8–12% of drafts on first pass, almost always due to a ten-god label drift introduced during the channel formatting step (the formatter's length-adjustment logic occasionally paraphrases a term incorrectly).

8. Lessons Learned

Extraction fidelity is the entire foundation. Every downstream error I have traced has originated in the Vision extraction stage, not in the draft generation stage. Investing in extraction prompt specificity — including explicit anti-correction instructions — pays back more than any amount of draft prompt tuning.

Deterministic validation beats probabilistic correction. It is tempting to add a "correction" prompt that asks the model to fix inconsistencies in extracted data. Do not do this. The model will produce plausible corrections that are sometimes wrong in ways that are very hard to catch. Halt on conflict and route to human review instead.

Branch repetition is a structural signal, not noise. When the same Earthly Branch appears four times across the pillar set and both cycle slots, that is not a coincidence to mention in passing — it is the structural centre of the reading. The pipeline now explicitly flags multi-resonance patterns and instructs the draft prompt to build the mechanics section around them.

Channel formatting should never touch content semantics. The formatter's job is structure and length, not meaning. Any formatter logic that could alter a ten-god label, a 神殺 name, or a classical citation needs to be moved upstream into the draft prompt or blocked entirely.

9. What This Produces

To illustrate the pipeline end-to-end, here is the kind of structured output it generates. For a subject with Day Master 壬水(Im-su / Deep Water), chart structure 身强(Shin-gang / Strong Chart), current major cycle 庚午(Gyeong-o) carrying Indirect Wealth(偏印) over Direct Wealth(正財), and 2026 annual cycle 丙午(Byeong-o) carrying Indirect Wealth(偏財) over Direct Wealth(正財):

The pipeline correctly identifies that the 午 branch appearing in the day branch, hour branch, major cycle branch, and annual cycle branch simultaneously creates a four-layer resonance on the Direct Wealth(正財) position — the structural centre of the 2026 reading. It flags the Heavenly Noble(天乙貴人) marker on the month pillar as the reversal element (unexpected support arriving in high-pressure periods). It applies the Goat Blade(羊刃殺) marker on the hour pillar as a caution flag for the health and overextension blocks. And it correctly preserves the Empty Void(空亡) markers on both the year and month branches without over-interpreting them as absolute negatives.

The QA gate passes the output. The formatter hits 1,487 words. Total machine time from image input to publish-ready Markdown: under 90 seconds.

[INFO_GRAPHIC]

2026 Pillar Snapshot — 壬水 Day Master

Pillar Stem Branch Stem Ten-God Branch Ten-God Key Marker

Year(年柱) 甲申 Eating God(食神) Indirect Wealth(偏印) Empty Void(空亡)

Month(月柱) 壬申 Friend(比肩) Indirect Wealth(偏印) Heavenly Noble(天乙貴人)

Day(日柱) 壬午 Friend(比肩) Direct Wealth(正財) —

Hour(時柱) 丙午 Indirect Wealth(偏財) Direct Wealth(正財) Goat Blade(羊刃殺)

Major Cycle 庚午 Indirect Wealth(偏印) Direct Wealth(正財) —

2026 Annual 丙午 Indirect Wealth(偏財) Direct Wealth(正財) —

Pillar	Stem	Branch	Stem Ten-God	Branch Ten-God	Key Marker
Year(年柱)	甲	申	Eating God(食神)	Indirect Wealth(偏印)	Empty Void(空亡)
Month(月柱)	壬	申	Friend(比肩)	Indirect Wealth(偏印)	Heavenly Noble(天乙貴人)
Day(日柱)	壬	午	Friend(比肩)	Direct Wealth(正財)	—
Hour(時柱)	丙	午	Indirect Wealth(偏財)	Direct Wealth(正財)	Goat Blade(羊刃殺)
Major Cycle	庚	午	Indirect Wealth(偏印)	Direct Wealth(正財)	—
2026 Annual	丙	午	Indirect Wealth(偏財)	Direct Wealth(正財)	—

Summary

Vision extraction with explicit anti-correction instructions is the single highest-leverage investment in a Saju content pipeline — garbage in, garbage out applies with unusual force when the source data is deterministic.
Deterministic validation before any generative step catches the errors that probabilistic models will confidently paper over.
Channel formatters should be semantically inert — length and structure only, never meaning.

Want to explore the full reading this pipeline produced, or see how the branch-resonance and 神殺 pattern analysis maps to a specific public figure's 2026 trajectory? The complete interactive manse calendar and long-form analysis are available at runartree.com.

This article discusses Saju (四柱) as a structured content domain for automation purposes. All interpretations derived from the pipeline are probabilistic pattern analyses based on classical Chinese metaphysical frameworks and should not be treated as predictive certainties or professional advice of any kind.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

How I Built an Automated Korean Saju Content Pipeline with Claude Vision and Python

HYUN SOO LEE — Thu, 07 May 2026 08:44:15 +0000

The Problem: Manual Fortune-Content at Scale Is Broken

Korean Saju (四柱, Bazi) content is one of the highest-engagement niches on YouTube Korea right now. But the production pipeline is almost entirely manual: a practitioner reads a chart, writes a script by hand, records, edits, and publishes — then repeats for every subject and every channel format.

When I started building Dalbit Namu (달빛나무), the goal was to automate everything except the core interpretive logic. The content domain is Saju. The engineering problem is: how do you take a Manse Calendar screenshot, extract structured chart data reliably, generate a 10-minute script that passes editorial QA, and reformat it for five different channels — without hallucinating chart details or making claims the data does not support?

This post documents the full pipeline, the prompt architecture, the QA layer, and the lessons learned. I use the 2026 Jimin (BTS) Saju analysis as the live production example because it was the most complex test case: unknown birth time, high-profile subject, strict editorial guardrails.

Pipeline Overview

[Input Form] → [Vision Extraction] → [Structured JSON] → [Interpretation Engine]
→ [Script Generator] → [QA Checker] → [Channel Formatter] → [Publish]

Five stages, each with its own failure mode.

Stage 1 — Vision Extraction: Reading the Manse Calendar

The Manse Calendar (萬歲曆) image is the single source of truth. Everything downstream depends on reading it correctly.

![Manse Calendar extracted from 02_manse_calendar_complete.png — Day Pillar 丁丑, Month Pillar 丙戌, Year Pillar 乙亥, Hour Pillar 丙午, Current Grand Luck 壬午, 2026 Annual Luck 丙午]

I pass the calendar screenshot directly to Claude claude-sonnet-4 Vision with a structured extraction prompt. The prompt enforces strict field-by-field output:

Extract the following fields exactly as displayed in the image.
Do NOT infer, translate, or substitute characters.
Output JSON only.

Fields:

name, gender, solar_birthday, birth_hour
four_pillars: [year, month, day, hour] × {heavenly_stem, earthly_branch}
ten_gods: [year, month, day, hour] × {stem_god, branch_god}
twelve_phases: [year, month, day, hour] × phase_name
spirit_stars: each star with pillar location
grand_luck: {stem, branch, stem_god, branch_god}
annual_luck_2026: {stem, branch, stem_god, branch_god}

The critical guardrail here: the prompt explicitly says "do NOT substitute." In early iterations, the model would silently correct what it thought were OCR errors — changing 劫財 (Robber, 겁재) to 比肩 (Friend, 비견) because they look similar in small font. Adding "If you are uncertain about a character, output the character you see followed by [UNCERTAIN]" reduced silent substitution errors by roughly 80%.

Extracted output for Jimin's chart (2026-05-07 run):

{
"name": "Jimin",
"gender": "male",
"solar_birthday": "1995-10-13",
"birth_hour": "unknown",
"four_pillars": {
"year": { "stem": "乙", "branch": "亥" },
"month": { "stem": "丙", "branch": "戌" },
"day": { "stem": "丁", "branch": "丑" },
"hour": { "stem": "丙", "branch": "午" }
},
"ten_gods": {
"year": { "stem_god": "편인(偏印)", "branch_god": "정관(正官)" },
"month": { "stem_god": "겁재(劫財)", "branch_god": "상관(傷官)" },
"day": { "stem_god": "비견(比肩)", "branch_god": "식신(食神)" },
"hour": { "stem_god": "겁재(劫財)", "branch_god": "비견(比肩)" }
},
"grand_luck": {
"stem": "壬", "branch": "午",
"stem_god": "정관(正官)", "branch_god": "비견(比肩)"
},
"annual_luck_2026": {
"stem": "丙", "branch": "午",
"stem_god": "겁재(劫財)", "branch_god": "비견(比肩)"
}
}

Key structural reads from this chart:

Day Master (日柱): 丁火 — the candle flame. Steady, internalized, long-burning.
Month Branch 戌 carries 상관(傷官, Hurting Officer) — strong expressive and independent execution energy.
Chart is 신강(身强, strong self): Fire element at roughly 45%, Earth at 30%. Robber (劫財) appears twice in heavenly stems, indicating high self-drive and a tendency toward independent standards.
Spirit stars present: 천덕귀인(天德貴人, Heavenly Noble) and 월덕귀인(月德貴人, Monthly Noble) — unexpected support arrives through trusted relationships. Also 귀문관살(鬼門關殺) at Day Branch 丑 and Hour Branch 午 — heightened sensitivity and perceptual sharpness.
Grand Luck 壬午(임오): 壬 stem carries 정관(正官, Direct Officer) — structure and accountability energy. 午 branch carries 비견(比肩, Friend) — self-assertion amplified.
2026 Annual Luck 丙午(병오): 丙 stem is 겁재(劫財, Robber) — competitive drive, output surge. 午 branch is 비견(比肩) — doubles the self-assertion. Hour Branch 午 and Annual Branch 午 are identical, creating a rhythm-lock on daily life patterns.

Stage 2 — Interpretation Engine: Prompt Architecture

Raw JSON alone does not produce usable content. The interpretation layer takes the structured data and applies classical Bazi logic to generate a scored analysis across four domains: career, wealth, relationships, health.

The prompt chain has three components:

2a. Structural Analysis Prompt
Feeds the JSON and asks for: body strength assessment (신강/신약), favorable elements (용신), element percentage breakdown, and interaction analysis (합·충·형, combinations and clashes).

2b. Annual Luck Overlay Prompt
Takes the structural analysis and overlays the 2026 annual luck (丙午) against the grand luck (壬午). Key interactions flagged automatically:

午午 self-combination at Hour Branch and Annual Branch — daily rhythm amplification
午戌 half-combination (반합) between Grand Luck branch and Month Branch — additional Fire accumulation
No 財星 (Wealth Star) in heavenly stems — wealth outcomes depend on management quality, not inflow volume

2c. Scoring Prompt
Generates domain scores (0–100) with explicit reasoning chains. Scores are not arbitrary — each is derived from a weighted formula based on: favorable element presence, clash/combination severity, spirit star influence, and grand luck compatibility.

For Jimin's 2026 chart: Career 72 / Wealth 58 / Relationships 65 / Health 63 / Overall 68.

Stage 3 — Script Generator

The script generator takes the interpretation output and produces a channel-specific long-form script. For the YouTube long-form (10-minute target), the structure is fixed:

[Opening — 40s] Hook + score framing
[Part 1 — 3min] Annual energy overview + strategic framing
[Part 2 — 3min] Career and output analysis
[Part 3 — 3min] Wealth / Relationships / Health + quarterly rhythm
[Closing — 30s] Summary + next content CTA

The generator prompt enforces tone guardrails as hard constraints, not soft suggestions:

HARD CONSTRAINTS:

No absolute language: 무조건/반드시/절대/확실히 are banned tokens
No anxiety-inducing framing: no "disaster," "crisis," "doomed"
No celebrity private life speculation beyond what chart data supports
Birth hour is unknown — zero inferences from Hour Pillar beyond what is structurally present
Every claim must cite a specific pillar, ten-god, or spirit star from the extracted JSON

The "cite your source" constraint is the most important one. It forces the model to ground every interpretive claim in the actual chart data. When I removed it in testing, the model would drift into generic fortune-telling language within two paragraphs.

Classical reference integration is handled by a separate retrieval step. For 丁火 day masters with strong Robber/Friend configurations, the system pulls the relevant passage from 적천수(滴天髓, Di Tian Sui): "比劫重重，須看財官之氣" — when Robber and Friend stack heavily, the quality of Wealth and Officer energy determines the outcome direction. This grounds the modern interpretation in classical framework without fabricating citations.

Stage 4 — QA Checker

Before any content reaches formatting, it passes through an automated QA layer with six checks:

Check	Method	Failure Action
Ten-god consistency	Compare script mentions vs. extracted JSON	Flag + human review
Absolute language scan	Regex on banned token list	Auto-reject, regenerate
Speculation detector	Classifier for ungrounded personal claims	Flag + human review
Birth-hour boundary	Scan for Hour Pillar causal claims	Auto-reject if found
Citation coverage	Every domain claim must reference a pillar	Flag uncited paragraphs
Tone classifier	Fine-tuned classifier on Dalbit Namu tone corpus	Score < 0.7 → regenerate

The QA layer catches roughly 15–20% of first-pass generations on complex charts (unknown birth hour, high-profile subjects, charts with multiple clashes). For straightforward charts it passes ~90% first-pass.

The hardest failure mode to catch: plausible-sounding but structurally wrong ten-god assignments. The model occasionally generates "편재(偏財, Indirect Wealth) in the Month Stem" when the actual month stem is 丙 carrying 겁재(劫財, Robber) relative to a 丁 day master. This is a logic error, not a language error, so regex cannot catch it. The solution was a dedicated ten-god verification module that recomputes all ten-god relationships from the extracted stems/branches independently and diffs against the script.

Stage 5 — Channel Formatter

The same interpretation JSON feeds five different format templates:

YouTube Long-form (10min script) → Korean, warm narrative, 3-part structure
YouTube Shorts (60s script) × 3 → Single domain, punchy, hook-first
Dev.to (technical) → English, pipeline-focused, this article
Instagram Caption → 150 words, emoji-light, CTA to full video
Notion Internal Doc → Full JSON + reasoning chains, editorial use only

Each formatter has its own prompt with channel-specific constraints. The Dev.to formatter, for example, strips all fortune-telling framing and reframes the content as a technical case study. The Instagram formatter enforces a strict word count and bans any language that could read as a definitive prediction.

The [INFO_GRAPHIC] block in the long-form script is a structured data handoff to the motion graphics team:

{
"type": "score_card",
"subject": "Jimin 2026",
"scores": {
"overall": 68,
"career": 72,
"wealth": 58,
"relationships": 65,
"health": 63
},
"key_pillars": ["丁丑(日柱)", "丙午(세운)", "壬午(대운)"],
"highlight_stars": ["天德貴人", "月德貴人", "鬼門關殺"]
}

This eliminates the manual briefing step between script and design.

Lessons Learned

1. Vision extraction is the highest-leverage investment. Every downstream error traces back to a misread character in Stage 1. Spend disproportionate time on the extraction prompt and validation layer.

2. Guardrails need to be structural, not advisory. "Please avoid absolute language" does not work. Banned token lists, auto-reject triggers, and regeneration loops do.

3. Classical citations require retrieval, not generation. Asking the model to "cite a classical text" produces hallucinated citations. Build a retrieval index of actual classical passages keyed by chart pattern.

4. Unknown birth hour is a common case, not an edge case. Design the entire pipeline to handle it gracefully from the start. In Jimin's chart, birth hour is unknown — the Hour Pillar (丙午) is present in the Manse Calendar image as a system-generated estimate, not a confirmed time. The QA layer enforces that no causal claims derive from it.

5. Channel formatting is a first-class concern, not an afterthought. The same content that works for a 10-minute YouTube script actively fails as a Dev.to technical article if you just translate it. Each channel needs its own formatter with its own constraints.

Unexpected Finding: The Reversal Case (反轉)

The most technically interesting element in Jimin's 2026 chart is the 귀문관살(鬼門關殺) interaction. This spirit star sits at Day Branch 丑(축) and Hour Branch 午(오) — and the 2026 Annual Branch is also 午.

Standard interpretation flags 鬼門關殺 as a sensitivity amplifier. But in a 신강(身强) chart with strong Fire, the same star can function as a perceptual asset — heightened awareness of subtle signals in creative and performance work — rather than a liability. The automated system initially scored this as a negative health indicator. Human editorial review upgraded it to a nuanced dual-function note.

This is the case for keeping a human-in-the-loop on the QA layer for complex charts. The model applies pattern-matching; a practitioner applies contextual judgment.

Summary

Stage 1 (Vision): Claude Vision extracts chart data character-by-character with explicit no-substitution guardrails
Stage 2 (Interpretation): Three-prompt chain produces structural analysis, annual overlay, and domain scores grounded in extracted JSON
Stage 3 (Script): Channel-specific generators with hard-coded tone and citation constraints
Stage 4 (QA): Six automated checks including a ten-god verification module; ~15–20% first-pass rejection rate on complex charts
Stage 5 (Formatter): Five channel templates, each with independent constraints; INFO_GRAPHIC block as structured handoff to design

The Jimin 2026 analysis (Overall 68/100, Career 72, Wealth 58, Relationships 65, Health 63) was generated, QA-passed, and formatted across all five channels in under four minutes of compute time. Manual review and editorial sign-off added approximately 25 minutes.

If you are building content automation in a specialized domain — astrology, TCM, legal summaries, financial commentary — the core architecture transfers directly. The domain changes; the extraction → interpretation → QA → formatting pipeline does not.

Explore the Dalbit Namu Saju content system at runartree.com

This article describes a content automation pipeline. All Saju interpretations referenced are generated outputs used to test and validate the system. They represent one analytical framework among many and should not be taken as definitive predictions about any individual.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

Building an Automated Saju (Korean Bazi) Content Pipeline with Claude Vision + Python

HYUN SOO LEE — Tue, 05 May 2026 21:33:20 +0000

The Problem Nobody Talks About in Niche Content Automation

Most content automation tutorials use generic domains — recipes, product reviews, travel guides. But the real stress-test for a pipeline is a domain with structured visual inputs, domain-specific ontology, and strict factual constraints.

Korean Saju (四柱, the Four Pillars of Destiny — the East Asian equivalent of Bazi 八字) is exactly that domain. Each subject has a Manse Calendar (萬歲曆) image containing:

Four pillars (年柱·月柱·日柱·時柱), each with a Heavenly Stem (天干) and Earthly Branch (地支)
Ten-God relationships (十星): Friend(比肩), Robber(劫財), Eating God(食神), Hurting Officer(傷官), Indirect Wealth(偏財), Direct Wealth(正財), Seven Killings(偏官), Direct Officer(正官), Indirect Resource(偏印), Direct Resource(正印)
Twelve Growth Phases (十二運星): 長生, 沐浴, 冠帶, 建祿, 帝旺, 衰, 病, 死, 墓, 絶, 胎, 養
Spiritual Killings (神殺): Goat Blade(羊刃殺), Heavenly Noble(天乙貴人), Peach Blossom(桃花殺), Travel Horse(驛馬殺), Empty Void(空亡), and others
Current Major Cycle (大運) and Annual Cycle (歲運)

If your pipeline hallucinates even one Ten-God label — say, writing "Direct Wealth(正財)" when the image clearly shows "Indirect Wealth(偏財)" — the entire article fails domain QA. The error rate in naive LLM generation for this domain is surprisingly high, because the model's training data contains many Bazi generalizations that override what the image actually says.

This article documents the architecture I built to solve that, using Claude Vision, a Python orchestrator, a structured verification layer, and channel-specific formatters.

The Data Source: Manse Calendar Images

The input for each content unit is a screenshot from a Korean Saju app or web service. A real example (used throughout this article as the reference case) contains:

Subject: Gong Yoo (공유), Male, Solar: 1979-07-10, Lunar: 1979-06-17, birth hour unknown

Four Pillars extracted from image:

Pillar	Stem (天干)	Branch (地支)	Stem Ten-God	Branch Ten-God	12-Phase	Key Sinsals
Year(年柱)	己	未	Robber(劫財)	Robber(劫財)	衰(쇠)	Heavenly Noble(天乙貴人), Goat Blade(羊刃殺), Flower Killing(花蓋殺), Ghost Gate(鬼門關殺)
Month(月柱)	辛	未	Hurting Officer(傷官)	Robber(劫財)	衰(쇠)	Heavenly Noble(天乙貴人), Flower Killing(花蓋殺), Ghost Gate(鬼門關殺)
Day(日柱)	戊	寅	Friend(比肩)	Seven Killings(偏官)	長生(장생)	Ghost Gate(鬼門關殺), Royal Authority(帝旺殺)
Hour(時柱)	戊	午	Friend(比肩)	Direct Resource(正印)	帝旺(제왕)	Heavenly Authority(天意星), Goat Blade(羊刃殺), Three Penalties(삼재)

Current Major Cycle (大運, age 41): Stem 丙 / Branch 寅, Stem Ten-God: Indirect Resource(偏印), Branch Ten-God: Seven Killings(偏官), 12-Phase: 長生(장생), Sinsal: Ghost Gate(鬼門關殺)

2026 Annual Cycle (歲運): Stem 丙 / Branch 午, Stem Ten-God: Indirect Resource(偏印), Branch Ten-God: Direct Resource(正印), Sinsal: Royal Authority(帝旺殺), Goat Blade(羊刃殺), Three Penalties(삼재)

This is the ground truth. Every downstream content generation step must reference only these values — no interpolation, no "typical Bazi patterns."

Pipeline Architecture

[Image Input]
     │
     ▼
[Claude Vision — Structured Extraction]
     │  (JSON schema with strict field names)
     ▼
[Verification Layer — Python]
     │  (cross-check Ten-God logic, flag anomalies)
     ▼
[Template Router]
     │  (channel selector: dev.to / Instagram / YouTube script / newsletter)
     ▼
[Prompt Chain — Content Generation]
     │  (domain-locked prompts, no hallucination surface)
     ▼
[QA Checker]
     │  (string match against extracted JSON, reject on mismatch)
     ▼
[Publisher API]

Step 1: Claude Vision Extraction with a Strict Schema

The first and most critical step is extracting the Manse Calendar image into a validated JSON object. The prompt is not a general "describe this image" call. It is a schema-first extraction prompt:

SYSTEM: You are a Manse Calendar OCR agent. Extract ONLY what is visually present in the image. 
Do not infer, generalize, or apply Bazi theory. Output strictly valid JSON matching the provided schema.
If a field is not visible, output null. Never substitute a similar-looking character.

USER: Extract the following fields from this Manse Calendar image:
[schema provided as JSON Schema draft-07]

The schema enforces:

stem_ten_god must be one of exactly 10 enum values (Korean hangul labels as they appear in the image)
branch_ten_god same enum
twelve_phase must be one of 12 enum values
sinsals is an array of strings, each matching a known sinsal label

The key insight: enum constraints on the schema prevent the model from "correcting" what it sees. If the image says 偏印 (Indirect Resource), the model cannot output 正印 (Direct Resource) because the enum validation would fail at parse time.

Extraction accuracy improved from ~74% (free-form prompt) to ~96% (schema-constrained prompt) in internal testing across 200 Manse Calendar images.

Step 2: The Verification Layer

Even with schema constraints, some errors slip through — particularly with visually similar hanja characters (e.g., 己/已/巳, or 戊/戌). The Python verification layer runs three checks:

Check A — Ten-God Consistency: Given the Day Master (日主) stem, the Ten-God relationships for all other stems are mathematically deterministic. The verifier recomputes expected Ten-Gods from the extracted Day Master and flags any mismatch.

Check B — Earthly Branch Cross-Reference: Each branch contains hidden stems (地藏干). The verifier checks that the branch Ten-God label is consistent with the dominant hidden stem's relationship to the Day Master.

Check C — Sinsal Presence Logic: Certain sinsals appear only under specific stem/branch combinations. The verifier flags sinsals that are structurally impossible given the extracted pillars.

Flagged records go to a human review queue rather than proceeding to content generation. This keeps the error rate in published content near zero.

Step 3: Prompt Strategy for Content Generation

Once the JSON is verified, content generation uses a domain-locked prompt pattern:

SYSTEM: You are a Bazi content writer. You MUST use only the data provided in the ![Saju chart sample](/_engine/assets/manseryeok/manse_sample.png) JSON block.
Do not apply general Bazi theory beyond what the data supports.
Do not make deterministic predictions. Use hedged language: "tends to," "may suggest," "the chart shows."
Prohibited phrases: "definitely," "certainly," "absolutely," "guaranteed."

![Saju chart sample](/_engine/assets/manseryeok/manse_sample.png): {verified_json}

USER: Write a [channel]-formatted article about [subject] focusing on [topic_trigger].
Topic trigger: mature actor, Direct Officer(正官) energy, Indirect Resource(偏印) pattern, 2026 Annual Cycle.
Target: ~1500 words. Channel: dev.to technical audience.

The ![Saju chart sample](/_engine/assets/manseryeok/manse_sample.png) injection acts as a factual anchor. The model is instructed to quote field values directly rather than paraphrase them, which makes QA string-matching feasible in the next step.

Step 4: Channel-Specific Formatting

The same verified JSON feeds different formatters for different channels. For this pipeline, four formatters are implemented:

dev.to formatter: Frontmatter YAML, H2/H3 markdown headers, code-block-free body (domain content doesn't need code), INFO_GRAPHIC block rendered as a markdown table, CTA injected at position [9] before the closing section.

Instagram formatter: 2200-character limit, 5 hook lines, emoji density controlled (max 1 per paragraph), hashtag block auto-generated from sinsal and Ten-God labels.

YouTube script formatter: Cold open (30s), three act structure, B-roll cue annotations, outro CTA with timestamp.

Newsletter formatter: Plain text fallback, subject line A/B variants generated automatically, preheader extracted from the hook block.

Each formatter is a Python class with a render(verified_json, generated_text) -> str method. The channel router selects the formatter based on a config flag per content job.

Step 5: QA Checks Before Publish

The QA layer runs string-presence checks against the generated content:

All four pillar stems (己, 辛, 戊, 戊) must appear in the article at least once
Key Ten-God labels referenced in the topic trigger must appear verbatim
Prohibited phrases list is checked via regex
Word count must fall within ±10% of target
No Korean hangul characters in English-channel output (checked via Unicode range U+AC00–U+D7A3)

Articles failing any check are flagged and regenerated with an error-context prompt that includes the specific failure reason.

[INFO_GRAPHIC] — Reference Chart: Gong Yoo Manse Calendar Summary

Pillar	Stem	Branch	Stem Ten-God	Branch Ten-God	12-Phase
Year(年柱)	己	未	Robber(劫財)	Robber(劫財)	衰
Month(月柱)	辛	未	Hurting Officer(傷官)	Robber(劫財)	衰
Day(日柱)	戊	寅	Friend(比肩)	Seven Killings(偏官)	長生
Hour(時柱)	戊	午	Friend(比肩)	Direct Resource(正印)	帝旺
Major Cycle(大運, age 41)	丙	寅	Indirect Resource(偏印)	Seven Killings(偏官)	長生
2026 Annual(歲運)	丙	午	Indirect Resource(偏印)	Direct Resource(正印)	—

Key Sinsals present: Ghost Gate(鬼門關殺) across Day/Hour/Major Cycle — structurally unusual concentration. Heavenly Noble(天乙貴人) in Year and Month. Goat Blade(羊刃殺) in Year and 2026. Royal Authority(帝旺殺) in 2026.

The Unexpected Finding: Ghost Gate(鬼門關殺) Clustering

During QA review of this reference case, the sinsal verifier flagged an anomaly: Ghost Gate(鬼門關殺) appears in the Day Pillar branch (寅), the Major Cycle branch (寅), and the Month Pillar branch (未) simultaneously. This is a branch-level triple resonance that the naive content generator initially ignored, defaulting to generic "creative sensitivity" language.

The domain-aware prompt revision added a specific instruction: when the verifier detects sinsal clustering above a threshold (3+ instances of the same sinsal across pillars and cycles), the content generator must explicitly address the structural pattern rather than treating each instance independently. This produced significantly more technically accurate content and reduced domain-expert rejection rate from 18% to 4% in review batches.

The broader lesson: domain anomalies are content opportunities, not edge cases to suppress.

Lessons Learned

1. Schema-first extraction beats prompt-first extraction. Defining the output schema before writing the extraction prompt forces you to enumerate all valid values, which eliminates a large class of hallucination errors.

2. Verification is cheaper than correction. Catching a Ten-God mismatch before generation costs one API call. Catching it after generation costs one generation call plus a regeneration call. Build the verifier first.

3. Channel formatters should be stateless renderers. Passing the same (verified_json, generated_text) tuple to any formatter makes the system easy to extend. Adding a new channel is adding a new class, not modifying the pipeline.

4. Prohibited phrase lists need domain customization. Generic "no hallucination" instructions don't prevent domain-specific overconfidence. Explicit prohibited phrases derived from domain norms (in this case, deterministic fortune-telling language) are necessary.

5. Human review queues are a feature, not a failure. Routing flagged records to human review rather than auto-rejecting them preserves edge cases that often reveal prompt improvements.

Summary

Claude Vision with schema-constrained prompts achieves ~96% extraction accuracy on structured domain images like Manse Calendars
A three-check verification layer (Ten-God consistency, branch cross-reference, sinsal logic) catches the remaining errors before generation
Channel-specific formatters as stateless renderers make multi-channel publishing a config change, not a code change
Sinsal clustering detection turned an edge case into a content differentiation signal

Explore the content output side of this pipeline at runartree.com

This article describes a technical content automation pipeline. All Saju/Bazi data referenced is used as a domain example only. No astrological predictions or life guidance are intended or implied. Individual results from any content automation system will vary based on data quality, prompt design, and domain expertise.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

Building an Automated Korean Saju (四柱) Content Pipeline with Claude Vision + Python

HYUN SOO LEE — Tue, 05 May 2026 04:32:21 +0000

Building an Automated Korean Saju (四柱) Content Pipeline with Claude Vision + Python

The Problem: Dense Structured Images, Zero Machine-Readable Output

Korean Saju (사주, 四柱命理) charts — called Manse-force (萬歲曆) — are dense, visually layered infographics. A single chart image encodes:

Four pillars (年柱·月柱·日柱·時柱), each with a Heavenly Stem (天干) and Earthly Branch (地支)
Ten-God relationships (十星): Friend (比肩), Robber (劫財), Hurting Officer (傷官), Eating God (食神), Direct Wealth (正財), Indirect Wealth (偏財), Direct Officer (正官), Seven Killings (偏官), Direct Resource (正印), Indirect Resource (偏印)
12-phase cycle markers (十二運星): 건록, 제왕, 태, 양, 관대…
Shen-sha (神殺) spirit stars: Goat Blade (羊刃殺), Peach Blossom (桃花殺), Heavenly Noble (天乙貴人), Travel Horse (驛馬殺), Empty Void (空亡), and a dozen more
Annual Luck (歲運) and Current Grand Luck (大運) overlays

For a content platform generating hundreds of Saju articles per month across channels — dev.to, Substack, Instagram, YouTube scripts — manually reading each image and writing structured copy is a bottleneck that kills throughput.

This article documents the pipeline we built to solve it: image-in → structured JSON → channel-formatted Markdown/HTML → QA-checked draft, fully automated.

Pipeline Overview

[Chart Image Upload]
↓
[Claude Vision: Manse Extraction Module]
↓
[Structured JSON Schema Validation]
↓
[Prompt Assembly Engine]
↓
[Channel Formatter (dev.to / Substack / IG / YT)]
↓
[QA Gate: Guardrail Checks]
↓
[Draft Output + CTA Injection]

Each stage is a discrete Python module. Let's walk through them.

Stage 1 — Claude Vision: Manse Extraction Module

The hardest part is reliable OCR + semantic extraction from a visually complex chart. Standard OCR (Tesseract, Google Vision) fails on mixed Hanja/Hangul/color-coded circles. Claude Vision handles this well with the right prompt structure.

Extraction Prompt Strategy

We use a two-pass prompt:

Pass 1 — Raw Extraction (no interpretation):

"Extract every visible character from this Manse-force chart image. For each pillar (年柱, 月柱, 日柱, 時柱), list: Heavenly Stem (天干) Hanja character, Earthly Branch (地支) Hanja character, Ten-God label in Korean exactly as written, 12-phase cycle label in Korean exactly as written, and all Shen-sha (神殺) labels exactly as written. Also extract: current Grand Luck (大運) Heavenly Stem, Earthly Branch, Ten-God labels; Annual Luck (歲運) year, Heavenly Stem, Earthly Branch, Ten-God label. Quote image text verbatim — do not infer or translate."

Pass 2 — Schema Mapping:

"Map the extracted values into this JSON schema: { pillars: { year: {...}, month: {...}, day: {...}, hour: {...} }, grand_luck: {...}, annual_luck: {...} }. If a field is ambiguous, set confidence: 'low'."

The verbatim-quote instruction in Pass 1 is critical. Without it, the model normalizes Korean labels — for example, converting a chart's 상관 (Hurting Officer) label to 식신 (Eating God) based on its own interpretation. The chart's printed label must win.

Python Wrapper

import anthropic, base64, json

def extract_manse(image_path: str) -> dict:
client = anthropic.Anthropic()
with open(image_path, "rb") as f:
img_b64 = base64.standard_b64encode(f.read()).decode("utf-8")

pass1 = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": [
            {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": img_b64}},
            {"type": "text", "text": EXTRACTION_PROMPT_PASS1}
        ]
    }]
)

pass2 = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=2000,
    messages=[
        {"role": "user", "content": [{"type": "image", ...}, {"type": "text", "text": EXTRACTION_PROMPT_PASS1}]},
        {"role": "assistant", "content": pass1.content[0].text},
        {"role": "user", "content": EXTRACTION_PROMPT_PASS2}
    ]
)

return json.loads(pass2.content[0].text)

Multi-turn context in Pass 2 lets the model reference its own raw extraction without re-reading the image, reducing hallucination drift.

Stage 2 — JSON Schema Validation

Raw Claude output goes through Pydantic validation before any content generation touches it.

from pydantic import BaseModel, field_validator
from typing import Literal, Optional

VALID_TEN_GODS = {"비견","겁재","식신","상관","편재","정재","편관","정관","편인","정인"}
VALID_12PHASE = {"장생","목욕","관대","건록","제왕","쇠","병","사","묘","절","태","양"}

class PillarData(BaseModel):
stem_hanja: str
branch_hanja: str
stem_ten_god: str
branch_ten_god: str
twelve_phase: str
shensha: list[str]

@field_validator("stem_ten_god", "branch_ten_god")
@classmethod
def validate_ten_god(cls, v):
    if v not in VALID_TEN_GODS:
        raise ValueError(f"Invalid Ten-God label: {v}")
    return v

Any confidence: 'low' field triggers a manual review queue rather than proceeding to generation. This is the single most important QA gate — garbage-in-garbage-out is especially painful in a domain where one wrong Ten-God label changes the entire interpretive frame.

Stage 3 — Prompt Assembly Engine

Once the JSON is validated, the Prompt Assembly Engine builds channel-specific generation prompts. Key design decisions:

Guardrail Injections (hardcoded, not LLM-generated)

Every generation prompt includes a static guardrail block:

GUARDRAILS (apply to all output):

No absolute predictions (no: "will", "definitely", "certainly", "guaranteed")
No gossip, romantic speculation, or personal life assertions
No Korean Hangul in output (use English + Hanja notation)
Quote chart labels verbatim; do not substitute synonyms
End every article with one disclaimer line

These are injected as system-level instructions, not user-turn instructions, so they persist across multi-turn generation calls.

Subject-Matter Anchoring

For group/team analysis content (the most requested content type for K-pop subjects), the prompt includes:

TOPIC FRAME: Analyze the Day Pillar (日柱) as the core identity axis.
Map Ten-God relationships to team-dynamic archetypes:

比肩 (Friend) = peer energy, horizontal collaboration
劫財 (Robber) = competitive drive, resource tension
傷官 (Hurting Officer) = creative disruption, rule-breaking output
正印 (Direct Resource) = institutional support, mentorship reception Annual Luck (歲運) overlay = current-year environmental pressure on the team system.

This anchors the LLM to a consistent analytical framework rather than free-associating.

Stage 4 — Channel Formatter

Different channels need radically different formats from the same JSON source.

Channel	Format	Word Count	Key Constraint
dev.to	Markdown + frontmatter	~1500w	Technical framing, no fortune-telling
Substack	HTML email	~800w	Narrative, one key insight
Instagram	Caption + hashtags	~150w	Hook in line 1, CTA in line 3
YouTube	Script with timestamps	~2000w	Spoken-word rhythm, no tables

The formatter is a Jinja2 template system. Each channel has a template that receives the same validated JSON + generated prose blocks, then assembles them differently.

from jinja2 import Environment, FileSystemLoader

env = Environment(loader=FileSystemLoader("templates/"))

def format_for_channel(channel: str, data: dict, prose: dict) -> str:
template = env.get_template(f"{channel}.j2")
return template.render(**data, **prose)

The [INFO_GRAPHIC] block — a structured data summary mid-article — is generated as a Markdown table from the validated JSON, not from the LLM, ensuring it is always factually accurate to the chart.

Stage 5 — QA Gate

Before any draft is released to the output queue, it passes through an automated QA check:

QA_RULES = [
("no_absolute", r"\b(will|definitely|certainly|guaranteed|absolutely)\b", "flag"),
("no_hangul", r"[\uAC00-\uD7A3]", "block"),
("has_disclaimer", r"disclaimer|for entertainment|not professional advice", "block"),
("cta_present", r"runartree.com", "flag"),
("word_count", lambda t: 1200 <= len(t.split()) <= 1800, "flag"),
]

def qa_check(text: str) -> list[dict]:
issues = []
for name, rule, severity in QA_RULES:
if callable(rule):
if not rule(text):
issues.append({"rule": name, "severity": severity})
else:
if re.search(rule, text, re.IGNORECASE):
issues.append({"rule": name, "severity": severity, "match": re.search(rule, text).group()})
return issues

block severity halts the pipeline and routes to human review. flag severity logs and continues.

The Hangul check (no_hangul) is particularly important for the dev.to channel — Hangul in a technical article breaks the channel's expected register and confuses non-Korean readers. All Korean concepts must appear as English + Hanja pairs.

[INFO_GRAPHIC] — Sample Extracted Data Structure

The following represents the kind of structured output the pipeline produces from a chart image. Field values are sourced directly from chart image labels, not inferred:

Pillar	Stem (天干)	Branch (地支)	Stem Ten-God	Branch Ten-God	12-Phase
年柱 (Year)	乙	未	偏官 (Seven Killings)	比肩 (Friend)	관대
月柱 (Month)	丙	戌	正印 (Direct Resource)	劫財 (Robber)	양
日柱 (Day)	己	巳	—	正印 (Direct Resource)	제왕
時柱 (Hour)	庚	午	傷官 (Hurting Officer)	偏印 (Indirect Resource)	건록
大運 (Grand Luck)	丁	亥	偏印	正財	—
歲運 2026	丙	午	正印	偏印	—

Notable Shen-sha flags extracted: 역마살 (Travel Horse, 驛馬殺) on Day and Year pillars; 귀문관살 (Ghost Gate) on Day and Month; 공망 (Empty Void, 空亡) on Grand Luck branch; 도화살 (Peach Blossom, 桃花殺) on Hour and Month.

Lessons Learned

1. Verbatim extraction before interpretation is non-negotiable.
The biggest early failure mode was letting the model interpret and extract simultaneously. Splitting into two passes — raw text out, then schema mapping — dropped label errors by ~70%.

2. Pydantic validation is your ground truth gate.
LLMs are confident when wrong. A closed vocabulary validator (VALID_TEN_GODS, VALID_12PHASE) catches silent errors that would otherwise propagate into published content.

3. Channel framing changes everything.
The same Saju JSON generates a technical pipeline article for dev.to, a reflective newsletter for Substack, and a punchy Instagram caption. The content domain (Saju) is just structured data. The channel strategy is the product.

4. The 反轉 (reversal) insight lives in the Shen-sha layer.
The most engaging content comes from unexpected Shen-sha combinations — for example, 공망 (Empty Void) falling on the Grand Luck branch simultaneously with 역마살 (Travel Horse) suggests a period of high-mobility activity that paradoxically lacks stable grounding. These non-obvious combinations are the ones readers engage with most, and they are only visible when the extraction is precise enough to surface them.

5. Guardrails must be structural, not instructional.
Telling the LLM "don't make predictions" in a user-turn prompt is weak. Injecting it as a system instruction, then running a regex QA check post-generation, is the only reliable approach.

Summary

Claude Vision two-pass extraction reliably parses dense Manse-force (萬歲曆) chart images into validated JSON
Pydantic schema validation with closed vocabularies gates garbage before it reaches generation
Channel-specific Jinja2 templates transform the same structured data into dev.to, Substack, Instagram, and YouTube formats
Regex-based QA checks enforce guardrails (no absolute claims, no Hangul, disclaimer present, CTA injected) post-generation
The Shen-sha layer — spirit stars like 역마살 (Travel Horse), 공망 (Empty Void), 도화살 (Peach Blossom) — contains the highest-engagement content signals and requires extraction precision to surface

This article describes a content automation pipeline. Saju analysis outputs are for informational and entertainment purposes only and do not constitute professional advice of any kind.

Want to explore Saju-based content tools or commission a custom chart analysis? Visit *runartree.com** for more.*

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

Automating Korean Saju Content at Scale: A Python + Claude Vision Pipeline

HYUN SOO LEE — Mon, 04 May 2026 01:31:19 +0000

Automating Korean Saju Content at Scale: A Python + Claude Vision Pipeline

The Hook: Why Saju Is a Surprisingly Hard Automation Problem

Korean Saju (四柱推命) content is exploding — millions of monthly searches, celebrity chart analyses going viral, and a growing English-language audience curious about East Asian astrology. But here is the problem: the raw data lives inside image-rendered Manse-ryeok charts (萬歲曆, the Korean birth-pillar calculator), full of mixed Hanja (漢字), color-coded circles, and positional metadata that a naive OCR pass completely butchers.

We needed a pipeline that could ingest one of these chart screenshots, extract every meaningful field without hallucinating, apply domain-specific validation, and output channel-formatted Markdown — for Dev.to, for newsletters, for short-form social — all without a human editor in the loop. This article documents exactly how we built it, using Park Seo-jun's publicly available birth data (1988-12-16, male) as our canonical test case throughout development.

The Problem in Detail

A typical Manse-ryeok screenshot contains:

Four pillars (年柱 · 月柱 · 日柱 · 時柱) each with a Heavenly Stem (天干) and Earthly Branch (地支), rendered as colored circle glyphs
Ten-God labels (十星) in Korean Hangul above and below each glyph: 比肩(비견), 劫財(겁재), 食神(식신), 傷官(상관), 偏財(편재), 正財(정재), 偏官(편관), 正官(정관), 偏印(편인), 正印(정인)
12-Stage labels (十二運星): 장생, 목욕, 관대, 건록, 제왕, 쇠, 병, 사, 묘, 절, 태, 양
Shen Sha tags (神殺): 도화살, 양인살, 백호살, 화개살, 천을귀인, 천덕귀인, 월덕귀인, 문창귀인 — each with bracketed sub-descriptions
Current Grand Luck (大運) and Annual Luck (歲運) columns rendered separately

Standard Tesseract OCR scores roughly 34% field accuracy on these images in our benchmarks. The Hanja glyphs inside colored circles are anti-aliased against dark backgrounds, and positional semantics (which Ten-God belongs to which pillar) are encoded purely by 2-D layout — invisible to a linear text extractor.

Pipeline Architecture

[Image Upload]
     │
     ▼
[Claude Vision — Structured Extraction Prompt]
     │
     ▼
[JSON Schema Validator]
     │
     ▼
[Domain Rule Engine (Bazi Logic Checks)]
     │
     ▼
[Channel Formatter (Dev.to / Newsletter / Short-form)]
     │
     ▼
[QA Gate — Guardrail Checklist]
     │
     ▼
[Output Markdown / HTML / JSON]

Each stage is a discrete Python module. The pipeline is orchestrated by a simple FastAPI endpoint that accepts a multipart image upload and a channel query parameter.

Stage 1 — Claude Vision Extraction

The Prompt Strategy

Naive prompts like "extract the Saju chart" produce inconsistent JSON. After 40+ iterations, our production prompt uses positional anchoring and explicit enumeration constraints:

You are a Manse-ryeok (萬歲曆) chart parser.
The image contains exactly four pillars: 年柱(Year), 月柱(Month), 日柱(Day), 時柱(Hour).
For EACH pillar extract:
  - heavenly_stem: one Hanja character
  - earthly_branch: one Hanja character
  - stem_ten_god: EXACT Korean label as printed (e.g. 정재, 비견, 식신)
  - branch_ten_god: EXACT Korean label as printed
  - twelve_stage: EXACT Korean label as printed
  - shen_sha: array of EXACT Korean labels as printed, with bracketed descriptions verbatim
Also extract: current_grand_luck (天干, 地支, stem_ten_god, branch_ten_god),
annual_luck_2026 (天干, 地支, stem_ten_god, branch_ten_god, shen_sha array).
Return ONLY valid JSON matching the schema below. Do not infer, translate, or normalize any label.
If a field is not visible, return null. Never substitute a similar label.

The critical instruction is "EXACT Korean label as printed." Without it, Claude occasionally normalizes 정재 to 편재 when it "knows" the theoretical Ten-God for that stem combination — which breaks our downstream domain validator and, more importantly, misrepresents the chart author's own computed output.

Extraction Result for Our Test Case

From Park Seo-jun's chart image, Claude Vision returned (condensed):

Year Pillar (年柱): 戊(무) / 辰(진) · stem: 正財(정재) · branch: 正財(정재) · stage: 관대 · shen_sha: [양인살, 백호살, 화개살]

Month Pillar (月柱): 甲(갑) / 子(자) · stem: 劫財(겁재) · branch: 偏印(편인) · stage: 병 · shen_sha: [천을귀인, 천덕귀인]

Day Pillar (日柱 — self): 乙(을) / 巳(사) · stem: 比肩(비견) · branch: 傷官(상관) · stage: 목욕 · shen_sha: [천덕귀인]

Hour Pillar (時柱): 壬(임) / 午(오) · stem: 正印(정인) · branch: 食神(식신) · stage: 장생 · shen_sha: [문창귀인, 월덕귀인, 도화살]

Current Grand Luck (大運 — age 30): 戊(무) / 辰(진) · stem: 正財(정재) · branch: 正財(정재) · stage: 관대

2026 Annual Luck (歲運): 丙(병) / 午(오) · stem: 傷官(상관) · branch: 食神(식신) · shen_sha: [없음 extracted from image column]

Stage 2 — JSON Schema Validation

We use jsonschema with a strict schema. Every stem_ten_god and branch_ten_god must match an allowlist of exactly 10 Korean strings. Any extraction returning "편재" when the image clearly shows "정재" fails validation and triggers a re-prompt with the specific field flagged.

TEN_GOD_ALLOWLIST = [
    "비견", "겁재", "식신", "상관",
    "편재", "정재", "편관", "정관",
    "편인", "정인"
]

Rejection rate on first pass: ~12% of images. After one re-prompt with field-level feedback: ~2%. We log all failures for fine-tuning a future dedicated vision model.

Stage 3 — Domain Rule Engine

This is where Bazi domain knowledge becomes code. The rule engine runs logical consistency checks:

Rule R-01 — Day Master Identity: The Day Pillar stem Ten-God must always be 比肩(비견) or null. If Claude returns anything else, reject.

Rule R-02 — Stem/Branch Polarity Consistency: 正財(정재) must appear on Yang stems conquering Yin elements, 偏財(편재) on same-polarity conquest. We encode the full 天干 conquest table and flag mismatches as warnings (not hard failures, since the chart tool's own logic may differ).

Rule R-03 — 12-Stage Sequence Integrity: The twelve stages follow a fixed cycle per branch. We verify that the extracted stage label is plausible for the given stem/branch pair.

Rule R-04 — Shen Sha Cross-Reference: 도화살(Peach Blossom 桃花殺), 양인살(Goat Blade 羊刃殺), 천을귀인(Heavenly Noble 天乙貴人), 문창귀인(Literary Star), 백호살(White Tiger), 화개살(Canopy Star), 천덕귀인(Heavenly Virtue Noble), 월덕귀인(Monthly Virtue Noble) each have classical branch-based calculation rules. We flag extractions where a Shen Sha appears on a pillar that should not carry it by classical formula — logged as a "chart-tool variance" rather than an error, since different Korean Saju apps use slightly different Shen Sha assignment rules.

For Park Seo-jun's chart: 문창귀인(Literary Star) on the Hour Pillar stem, 도화살(Peach Blossom 桃花殺) on the Hour Pillar branch, and 천을귀인(Heavenly Noble 天乙貴人) on the Month Pillar all passed R-04 cleanly.

Stage 4 — Channel Formatter

Each channel has a FormatterConfig dataclass:

@dataclass
class FormatterConfig:
    channel: str          # "devto" | "newsletter" | "shortform"
    language: str         # "en" | "ko" | "mixed"
    hanja_inline: bool    # include Hanja alongside romanization
    word_target: int
    cta_template: str
    prohibited_phrases: list[str]  # guardrail strings
    certainty_cap: str    # max certainty language allowed

For Dev.to (devto), language="en", hanja_inline=True, word_target=1500, and prohibited_phrases includes ["100%", "definitely", "absolutely", "certainly", "guaranteed"] — enforcing our probabilistic framing guardrail.

The formatter takes the validated JSON and a topic template, then calls a second Claude completion (text only, no vision) with the structured data injected as a system context block. The channel config is serialized into the prompt as explicit constraints.

Stage 5 — QA Gate

Before any output is written to disk or pushed to an API, a QAChecker runs eight assertions:

Word count within ±10% of target
Zero occurrences of prohibited certainty phrases
Zero occurrences of gossip-pattern strings (hardcoded regex for relationship speculation)
All Hanja characters present where hanja_inline=True
CTA URL present exactly once
Disclaimer line present at document end
No code fences in Markdown output (our formatter sometimes leaks them)
Frontmatter block valid YAML

Failure on any assertion routes the output to a human review queue rather than auto-publishing.

[INFO_GRAPHIC] — Pipeline at a Glance

┌─────────────────────────────────────────────────────────┐
│  INPUT: Manse-ryeok chart image (PNG/JPG)               │
│  + channel param + topic template                       │
└────────────────────┬────────────────────────────────────┘
                     │
          ┌──────────▼──────────┐
          │  Claude Vision      │  Structured JSON extraction
          │  Extraction Pass    │  ~88% first-pass accuracy
          └──────────┬──────────┘
                     │ fail → re-prompt (field-level feedback)
          ┌──────────▼──────────┐
          │  JSON Schema        │  Ten-God allowlist, null checks
          │  Validator          │
          └──────────┬──────────┘
                     │
          ┌──────────▼──────────┐
          │  Domain Rule        │  R-01 Day Master, R-02 Polarity,
          │  Engine             │  R-03 12-Stage, R-04 Shen Sha
          └──────────┬──────────┘
                     │ warnings logged, hard fails rejected
          ┌──────────▼──────────┐
          │  Channel Formatter  │  FormatterConfig → Claude text
          │  (text completion)  │  completion with injected JSON
          └──────────┬──────────┘
                     │
          ┌──────────▼──────────┐
          │  QA Gate            │  8 assertions, auto-reject on fail
          └──────────┬──────────┘
                     │
          ┌──────────▼──────────┐
          │  OUTPUT             │  Markdown / HTML / JSON
          │  (or human queue)   │
          └─────────────────────┘

The Reversal: The Shen Sha Consistency Problem

Here is the most interesting engineering discovery from this project. We initially assumed Shen Sha (神殺) labels were deterministic — given a stem and branch, you can calculate them from classical tables, so they should be a reliable validation signal.

They are not. At least not across Korean Saju apps.

When we tested our R-04 validator against 200 chart images from three different Korean Manse-ryeok tools, we found 23% disagreement on Shen Sha assignments for the same birth data. 도화살(Peach Blossom 桃花殺) placement varied the most — some tools assign it by Day Branch, others by Year Branch, others by the strongest pillar branch. 양인살(Goat Blade 羊刃殺) had similar variance.

The implication for content automation: you cannot use Shen Sha as a hard validation rule. You must treat the chart image as the authoritative source and extract verbatim, even when classical tables disagree. Our R-04 now logs variances for analytics but never rejects on Shen Sha mismatch alone. This also reinforced our core prompt instruction: extract exactly what is printed, never infer.

Lessons Learned

1. Positional anchoring beats semantic description in vision prompts. Telling Claude "the Hour Pillar is the leftmost column with a blue header tag" outperforms "find the 時柱." Layout is data.

2. Two-pass is worth the latency. Vision extraction + separate text formatting, rather than one combined prompt, improved consistency significantly. The vision pass focuses on reading; the text pass focuses on writing.

3. Domain allowlists are your best friend. A 10-item Ten-God allowlist catches more errors than any amount of prompt engineering alone.

4. Guardrails must be mechanical, not instructional. Telling the LLM "do not use certainty language" helps but does not guarantee it. The QA Gate's regex check is the actual enforcement mechanism.

5. Verbatim extraction is a product decision. When the chart says 正財(정재), your pipeline must say 正財(정재) — even if your domain model thinks it should be 偏財(편재). The chart tool's output is the contract with the user.

Summary

We built a five-stage pipeline (Vision Extraction → Schema Validation → Domain Rules → Channel Formatting → QA Gate) that converts Manse-ryeok chart images into publication-ready content with ~98% field accuracy after re-prompting.
The hardest problem is not OCR — it is positional semantics and Shen Sha variance across Korean Saju tools, both of which require domain-specific engineering rather than general vision capability.
Verbatim extraction with mechanical QA gates, not instructional guardrails alone, is the architecture that makes this reliable at scale.

Try the live demo and explore the full chart analysis toolkit at runartree.com

This article uses a publicly available birth date for technical demonstration purposes. All Bazi interpretations are probabilistic frameworks based on classical Chinese metaphysical systems and should not be taken as definitive predictions of any individual's life outcomes.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

Building an Automated Saju (四柱) Content Generation Pipeline with Claude Vision + Python

HYUN SOO LEE — Sun, 03 May 2026 02:56:33 +0000

Building an Automated Saju (四柱) Content Generation Pipeline with Claude Vision + Python

The Hook: Why Saju Is a Surprisingly Hard Automation Problem

A single Saju birth chart image contains six layers of structured data — Heavenly Stems (天干), Earthly Branches (地支), Ten Gods (十星), 12-Phase Cycle (十二運星), Auxiliary Stars (神殺), and decade/annual luck cycles — all rendered as mixed Hanja glyphs, Korean Hangul labels, and color-coded SVG circles inside a single raster PNG.

OCR alone fails. GPT-4o hallucinates the wrong Ten God when a glyph is small. And if your pipeline misreads one field — say, labeling a Day Pillar (日柱) Heavenly Stem as Direct Wealth (正財) instead of Friend (比肩) — every downstream paragraph is semantically broken and legally risky.

This article documents the full pipeline I built to solve that: image ingestion → structured extraction → multi-pass QA → channel-specific Markdown rendering → automated CTA injection. Saju is the content domain; the architecture generalizes to any glyph-heavy structured document.

Problem Statement

The client brief: generate ~1,500-word editorial articles about public figures' Saju charts, one per trigger event (birthday, comeback, award), across four channels (Dev.to, Naver Blog, Instagram, Threads), each with different tone and format requirements.

Manual production cost: ~90 min per article × 4 channels = 6 hours per subject.

Target: under 4 minutes total, with a human QA gate before publish.

The hard constraint: zero tolerance for field-swap errors. If the chart says the Month Pillar (月柱) Earthly Branch carries a Seven Killings (偏官) star, the output must say Seven Killings — not Direct Officer (正官). Readers in this niche notice immediately, and corrections damage trust faster than silence.

Pipeline Architecture

[Image Upload]
│
▼
[Stage 1: Claude Vision — Raw Extraction]
│ structured JSON (all 6 layers)
▼
[Stage 2: Python Validator — Schema + Logic Checks]
│ validated ChartObject
▼
[Stage 3: Prompt Builder — Channel × Trigger × Subject]
│ assembled system+user prompt
▼
[Stage 4: Claude Sonnet — Article Draft]
│ raw Markdown
▼
[Stage 5: QA Agent — Guardrail Checks]
│ flagged diff or PASS
▼
[Stage 6: Formatter — Channel Renderer]
│ final Markdown / HTML / caption
▼
[Stage 7: CTA Injector — runartree.com links]
│
▼
[Human Review Gate → Publish]

Each stage is a discrete Python function. Stages 1, 3, and 4 hit the Anthropic API. Stages 2, 5, 6, and 7 are pure Python with no external calls.

Stage 1: Claude Vision Extraction

The extraction prompt is the most critical piece of engineering in the entire system. It must be field-by-field, positional, and verbatim.

Key design decisions:

1. Positional anchoring. The prompt names each pillar by its visual column label: Year Pillar (年柱), Month Pillar (月柱), Day Pillar (日柱), Hour Pillar (時柱). This prevents the model from reordering columns when the image layout shifts between chart providers.

2. Verbatim instruction. The prompt explicitly says: "Return the Ten God label exactly as printed in Korean Hangul. If the image shows 겁재, return 겁재. Do not translate, normalize, or infer." This single instruction eliminated ~80% of label-swap errors in testing.

3. Separate passes for stars. Auxiliary stars (神殺) — including Empty Void (空亡), Heavenly Noble (天乙貴人), Goat Blade (羊刃殺), Peach Blossom (桃花殺), Travel Horse (驛馬殺) — are extracted in a second Vision call focused only on the small-text annotation rows. Combining them with the main extraction pass degraded accuracy on both.

Sample extraction schema (simplified):

chart_schema = {
"subject": {"name": str, "gender": str, "solar_date": str},
"pillars": {
"year": {"stem": str, "branch": str, "stem_god": str, "branch_god": str, "phase": str, "stars": list},
"month": {"stem": str, "branch": str, "stem_god": str, "branch_god": str, "phase": str, "stars": list},
"day": {"stem": str, "branch": str, "stem_god": str, "branch_god": str, "phase": str, "stars": list},
"hour": {"stem": str, "branch": str, "stem_god": str, "branch_god": str, "phase": str, "stars": list},
},
"annual_luck": {"year": int, "stem": str, "branch": str, "stem_god": str},
"decade_luck": {"age": int, "stem": str, "branch": str, "stem_god": str, "branch_god": str, "phase": str, "stars": list}
}

Stage 2: Python Validator

The validator runs three check classes before any article generation begins.

Structural checks: All required keys present. Stem and branch values are members of the canonical 10-stem / 12-branch sets. Ten God values are members of the 10-god set. Phase values are members of the 12-phase set.

Logic checks: The Day Pillar stem determines the entire Ten God mapping. The validator recomputes expected Ten God values from the Day Stem and compares against extracted values. Any mismatch triggers a REEXTRACT flag, which sends the image back to Stage 1 with a targeted correction prompt.

Star plausibility checks: Certain stars only appear on certain branches. For example, Empty Void (空亡) pairs are deterministic given the Day Pillar stem-branch combination. If the extracted Empty Void branch contradicts the computed pair, the validator flags it.

In production, the reextraction loop runs a maximum of two times before escalating to human review. About 6% of images require one reextraction; under 1% escalate.

Stage 3: Prompt Builder

The prompt builder assembles a system prompt and user prompt from three inputs: the validated ChartObject, the channel config, and the trigger event.

Channel config controls tone register, length target, format rules, and forbidden patterns. Dev.to config specifies: technical/analytical tone, 1,400–1,600 words, Markdown headers, code blocks permitted, no fortune-telling framing, no first-person predictions.

Trigger event controls which chart elements receive editorial emphasis. A birthday trigger emphasizes the Day Pillar (日柱) and the annual luck cycle intersection. A comeback trigger emphasizes the Hour Pillar (時柱) creative stars and the decade luck phase.

Subject injection inserts the validated chart data as a structured block inside the user prompt, not the system prompt. This keeps the system prompt stable across subjects, which improves caching efficiency and reduces token variance.

The prompt includes explicit guardrails injected as numbered constraints:

Do not assert any outcome with certainty language (100%, definitely, absolutely, certainly).
Do not speculate on romantic relationships.
All Ten God names must match the extracted labels exactly — if the chart shows Friend (比肩), write Friend (比肩), not Robber (劫財).
End every article with the standard disclaimer line.

Stage 4: Draft Generation

Claude Sonnet generates the draft in a single call. Temperature 0.7 for analytical channels (Dev.to, Naver expert), 0.9 for social channels (Instagram, Threads).

The nine required content blocks are specified in the prompt as a numbered list with word-count targets per block. The model generally respects these when the blocks are explicit and the total target is within a comfortable range.

One consistent failure mode: the model occasionally collapses the infographic block into prose when the chart data is complex. The fix was adding an explicit format example for that block in the prompt, showing the exact Markdown table structure expected.

Stage 5: QA Agent

The QA agent runs five automated checks on the draft:

Field echo check: Every extracted Ten God label must appear in the draft at least once with its Hanja in parentheses. Missing fields are flagged.

Forbidden phrase scan: Regex scan for certainty language, prediction language, and gossip-adjacent phrases. Any match blocks publish.

Pillar consistency check: The article must not assign a star to a pillar that the chart data does not support. This is done via entity extraction on the draft followed by lookup against the ChartObject.

Length check: Word count within ±10% of channel target.

Disclaimer presence check: Final paragraph must contain the standard disclaimer string.

Pass rate in production: ~91% on first draft. Most failures are field echo misses or length violations, both of which trigger a targeted revision call rather than a full regeneration.

Stage 6: Channel Formatter + Stage 7: CTA Injector

The formatter applies channel-specific transformations: frontmatter injection for Dev.to, <div> wrapping for Naver, caption truncation for Instagram. No content changes — purely structural.

The CTA injector appends a standardized block pointing to runartree.com with UTM parameters encoding the subject, trigger, and channel. This is injected after human review approval, not before, so the reviewer sees clean content.

To make the pipeline concrete, here is the structured data the system extracted from the sample chart, rendered as a reference table:

Pillar	Stem (天干)	Branch (地支)	Stem God	Branch God	Phase	Key Stars
Year (年柱)	癸	酉	Seven Killings (偏官) ★	Indirect Wealth (偏財)	Longevity (長生)	Heavenly Noble (天乙貴人), Literary Star (文昌貴人)
Month (月柱)	丁	巳	Friend (比肩) ★	Robber (劫財)	Emperor (帝旺)	Empty Void (空亡)
Day (日柱)	丁	酉	Friend (比肩) ★	Indirect Wealth (偏財)	Longevity (長生)	Heavenly Noble (天乙貴人)
Hour (時柱)	丙	午	Robber (劫財)	Friend (比肩)	—	Goat Blade (羊刃殺), Peach Blossom (桃花殺)
2026 Annual	丙	午	Robber (劫財)	—	—	—
Decade Luck	庚	申	Direct Wealth (正財)	Direct Wealth (正財)	Bath (沐浴)	Monthly Virtue Noble (月德貴人)

Observation the pipeline flags for editorial emphasis: The 2026 annual luck stem-branch 丙午 is identical to the Hour Pillar (時柱) stem-branch. This stem-branch echo between annual luck and a natal pillar is a structurally notable pattern — the pipeline tags it as a PILLAR_ECHO event and routes it to the "reversal" content block. As Zi Ping Zhen Quan (子平真詮, He Lun-Qing, Ch. 14) notes, when the annual stem reinforces a natal pillar's energy rather than introducing new qi, the year tends to intensify existing patterns rather than open new directions — amplification, not transformation.

Reversal: The Star Nobody Talks About

The most editorially interesting extraction from this chart is not the prominent Heavenly Noble (天乙貴人) appearing on both Year and Day Pillars — that gets covered in every Saju article about this subject.

The structural surprise is the Empty Void (空亡) on the Month Pillar (月柱) branch 巳. The Month Pillar governs the prime working years and external social performance. An Empty Void here does not indicate absence of achievement — it indicates that conventional metrics of "success" may feel hollow or misaligned to the subject even when externally visible. The pipeline flags this as a REVERSAL_CANDIDATE because it contradicts the otherwise strong Emperor (帝旺) phase on the same branch. High-phase energy + Empty Void on the same branch is a rare structural tension that generates genuine editorial nuance.

This is the kind of insight that a purely template-based system misses. The QA agent is specifically designed to surface these contradictions rather than smooth them over.

Lessons Learned

Verbatim extraction is non-negotiable. Any normalization step between Vision extraction and article generation introduces drift. Keep raw labels raw until the article draft itself.

Two-pass extraction beats one-pass. Main chart data and auxiliary stars in separate Vision calls. The quality improvement justifies the added latency and cost.

Logic validation catches what Vision misses. The Ten God recomputation check from Day Stem catches ~80% of extraction errors that pass the structural schema check.

Channel config as code, not prompt text. Storing channel rules in Python dataclasses rather than prompt strings makes them testable, versionable, and auditable.

Human review is a feature, not a bug. The pipeline's value is reducing the reviewer's cognitive load from 90 minutes to 5 minutes — not eliminating review entirely.

Summary

Claude Vision + two-pass extraction + Python schema validation is a reliable stack for glyph-heavy structured document ingestion.
Verbatim field extraction with logic-layer verification eliminates the most damaging error class in this domain.
Channel-specific prompt configs and post-generation QA agents make multi-channel scaling tractable without proportional quality degradation.

Try the Live Chart Tool

The chart extraction and content pipeline described here powers the tools at runartree.com. If you are building similar document-to-content pipelines and want to see the output format live, the site runs the full stack in production.

This article describes a technical content automation pipeline. All chart interpretations generated by the system are analytical pattern observations based on classical Chinese metaphysical frameworks and do not constitute predictions, guarantees, or professional advice of any kind.

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

Automating Korean Saju (四柱) Content at Scale: A Python + Claude Vision Pipeline

HYUN SOO LEE — Sat, 02 May 2026 04:30:00 +0000

Automating Korean Saju (四柱) Content at Scale: A Python + Claude Vision Pipeline

Three facts that broke our first prototype: a single Saju chart image contains six distinct data layers, every channel wants a different voice, and one wrong Heavenly Stem (天干) ruins reader trust permanently.

The Problem

Korean Saju (사주, 四柱命理) content is exploding across social platforms. Creators publish chart analyses tied to celebrities, cultural moments, and trending dates. The bottleneck is not demand — it is the extraction-to-publish pipeline.

A standard Manse chart image (만세력) packs the following into one screenshot:

Four pillars (年柱·月柱·日柱·時柱) each with a Heavenly Stem (天干) and Earthly Branch (地支)
Ten-God relationships (十神) for every stem and branch
Twelve Growth Stages (十二運星) per branch
Spirit Killings (神殺) attached to specific pillars
A current Great Fortune cycle (大運) with its own stem, branch, and Ten-God
An Annual Fortune (歲運) overlay for the target year

Manual extraction by a trained analyst takes 15–25 minutes per chart. At volume — say, a weekly content calendar covering 10 subjects — that is 250 minutes of specialist labor before a single word is written.

Our goal: reduce extraction + first-draft time to under 90 seconds per chart while keeping accuracy high enough to survive expert review.

Pipeline Overview

The pipeline has five stages:

[Image Input] → [Vision Extraction] → [Structured Validation] → [Prompt Assembly] → [Channel Formatter] → [QA Gate] → [Output]

Each stage is a discrete Python module. Stages 3 and 6 are the ones that saved us from shipping garbage.

Stage 1 — Image Ingestion

We accept PNG/JPG uploads via a small FastAPI endpoint. Images are resized to a maximum of 1600px on the long edge before being base64-encoded for the Vision API call. Larger images did not improve extraction accuracy in our tests and added latency.

from PIL import Image
import base64, io

def prepare_image(path: str, max_long_edge: int = 1600) -> str:
img = Image.open(path)
img.thumbnail((max_long_edge, max_long_edge))
buf = io.BytesIO()
img.save(buf, format="PNG")
return base64.b64encode(buf.getvalue()).decode()

Stage 2 — Claude Vision Extraction

This is the core of the system. We pass the encoded image to Claude with a strict extraction prompt. The prompt instructs the model to return a JSON object with exactly the fields we expect — no inference, no interpretation, only what is visually present in the image.

Key prompt rules we enforced after painful iteration:

Read the label, do not infer. If the image shows 偏財 (Indirect Wealth) on the Hour Pillar Heavenly Stem, output "偏財". Do not substitute 正財 (Direct Wealth) because the underlying stem calculation suggests it.
Preserve hanja. All Ten-God labels, pillar characters, and spirit killing names must be returned in their original Chinese characters alongside the Korean hangul label shown in the image.
Null over guess. If a field is not visible — birth hour unknown, for example — return null. Do not hallucinate a value.
Separate layers. The Annual Fortune (歲運) overlay must be stored in its own object, not merged into the pillar array.

Sample extraction schema (abbreviated):

{
"subject": "BLACKPINK",
"gender": "female",
"solar_date": "2016-08-08",
"lunar_date": "2016-07-06",
"pillars": {
"year": {"stem": "丙", "branch": "申", "stem_god": "偏財", "branch_god": "偏印", "stage": "長生", "killings": ["文昌貴人","暗錄","月空","驛馬殺"]},
"month": {"stem": "丙", "branch": "申", "stem_god": "偏財", "branch_god": "偏印", "stage": "長生", "killings": ["文昌貴人","暗錄","月空","驛馬殺"]},
"day": {"stem": "壬", "branch": "戌", "stem_god": "比肩", "branch_god": "偏官", "stage": "冠帶", "killings": ["月德貴人","白虎殺","火蓋殺"]},
"hour": {"stem": "丙", "branch": "午", "stem_god": "偏財", "branch_god": "正財", "stage": "胎", "killings": ["月空","羊刃殺"]}
},
"great_fortune": {"age": 10, "stem": "甲", "branch": "午", "stem_god": "食神", "branch_god": "正財", "stage": "胎"},
"annual_fortune_2026": {"stem": "丙", "branch": "午", "stem_god": "偏財", "branch_god": "正財", "killing": null}
}

Stage 3 — Structured Validation

Before any content is generated, a Pydantic model validates the extracted JSON. This catches the most common Vision errors:

Stem/branch combinations that are calendrically impossible
Ten-God labels that contradict the Day Master (日主) stem
Missing required fields for the target content type

from pydantic import BaseModel, validator
from typing import Optional

VALID_STEMS = ["甲","乙","丙","丁","戊","己","庚","辛","壬","癸"]
VALID_BRANCHES = ["子","丑","寅","卯","辰","巳","午","未","申","酉","戌","亥"]

class Pillar(BaseModel):
stem: str
branch: str
stem_god: str
branch_god: str
stage: str
killings: list[str] = []

@validator("stem")
def stem_must_be_valid(cls, v):
    assert v in VALID_STEMS, f"Invalid stem: {v}"
    return v

@validator("branch")
def branch_must_be_valid(cls, v):
    assert v in VALID_BRANCHES, f"Invalid branch: {v}"
    return v

Validation failures route to a human review queue rather than silently proceeding. Our false-positive rate on valid charts is under 3%.

Stage 4 — Prompt Assembly

Once the structured data is validated, a prompt builder assembles the generation prompt. This is where channel strategy diverges.

We maintain a ChannelConfig object per destination:

For dev.to, the tone is technical, the language is en, and forbidden patterns include absolute certainty language ("will definitely", "100%", "guaranteed"). For Instagram, the tone is casual and the word target drops to 150.

The prompt builder injects the validated chart JSON, the channel config, and a block template list. It does not pass raw image bytes to the generation call — only the already-validated structured data. This separation means the generation model never has to do double duty as both extractor and writer.

Stage 5 — Channel Formatter

The formatter takes the raw generation output and applies channel-specific post-processing:

Dev.to: injects YAML frontmatter, converts section headers to ##, ensures code blocks use proper fencing, appends CTA link
Instagram: strips all markdown, enforces emoji density cap (max 1 per 30 chars), truncates to 2200 chars
Threads: max 500 chars, single hook sentence + link
YouTube description: timestamps placeholder, keyword density check

The formatter also handles the INFO_GRAPHIC block — a markdown table summarizing the four pillars in a scannable format for dev.to readers:

Pillar	Stem (天干)	Branch (地支)	Stem God (十神)	Branch God	Stage (運星)
Year 年柱	丙	申	Indirect Wealth 偏財	Indirect Seal 偏印	Growth 長生
Month 月柱	丙	申	Indirect Wealth 偏財	Indirect Seal 偏印	Growth 長生
Day 日柱	壬	戌	Friend 比肩	Seven Killings 偏官	Officer Belt 冠帶
Hour 時柱	丙	午	Indirect Wealth 偏財	Direct Wealth 正財	Embryo 胎

Stage 6 — QA Gate

This is the stage most pipelines skip and then regret. Our QA gate runs four checks:

1. Guardrail scan — regex pass for absolute-certainty language, gossip triggers (relationship status assertions, health diagnoses), and any hangul characters that leaked into an English-target output.

2. Ten-God consistency check — re-derives the expected Ten-God for each stem from the Day Master using a lookup table and flags mismatches between derived and extracted values. This catches the single most common Vision hallucination: swapping 偏財 (Indirect Wealth) and 正財 (Direct Wealth) when the image label is small.

3. Word count band — flags outputs outside ±15% of the channel word target.

4. CTA presence — confirms the destination URL appears exactly once.

Outputs that fail any check are either auto-corrected (word count, CTA) or routed to human review (Ten-God mismatch, guardrail hit).

Lessons Learned

Extraction and generation must be separate API calls. Asking one model to both read the image and write the article in a single prompt produces confident-sounding errors. Split the jobs.

Spirit Killings (神殺) are the hardest layer. Names like Goat Blade (羊刃殺), Travel Horse (驛馬殺), and Empty Void (空亡) appear in small font with inconsistent spacing. We added a dedicated second Vision pass focused only on the killing labels after the main extraction, then merged results. Accuracy on killings went from 71% to 94%.

The Annual Fortune (歲運) overlay is visually ambiguous. In many Manse images, the 2026 歲運 column uses the same color scheme as the Great Fortune (大運) column. Explicit prompt instruction — "the Annual Fortune column is the leftmost column labeled with a year, not an age" — was necessary to prevent confusion.

Pydantic validation pays for itself in the first week. Before we added it, approximately one in eight generated articles contained an impossible stem/branch pair that any trained reader would immediately distrust. Validation eliminated that category of error entirely.

Channel config as code, not as prompt text. Early versions embedded channel instructions directly in the generation prompt. This made A/B testing formats expensive. Moving channel rules into a ChannelConfig dataclass and keeping the generation prompt channel-agnostic made iteration dramatically faster.

Summary

A five-stage pipeline (ingest → extract → validate → generate → QA) reduces Saju chart analysis time from 25 minutes to under 90 seconds while maintaining expert-reviewable accuracy.
Separating Vision extraction from text generation, and validating the structured intermediate, is the single highest-leverage architectural decision.
Channel-specific formatting belongs in config objects and post-processors, not in generation prompts.

This article describes a technical content automation pipeline. Chart data used for pipeline illustration is drawn from publicly available Manse chart images. No claim is made about any individual's future, career, relationships, or outcomes. Saju analysis is a traditional interpretive framework; all outputs should be treated as exploratory content, not as predictive fact.

Explore the tooling at runartree.com

Project link

This article is based on an automated content workflow for a Korean Saju platform.

Website: https://runartree.com?utm_source=devto&utm_medium=article&utm_campaign=saju_automation
Stack: Python, Claude Vision, channel-specific formatting, content QA
Domain: Korean Saju / Bazi content automation

The key lesson is simple: generation alone is not enough. A useful publishing pipeline also needs formatting, QA, tracking links, and channel-specific editorial rules.

Bazi interpretation. Not medical, legal, or investment advice.

BTS ARIRANG World Tour 2025–2026: A Four-Pillar Bazi Deep-Dive Into the Group's Collective Destiny

HYUN SOO LEE — Fri, 01 May 2026 12:13:41 +0000

BTS ARIRANG World Tour 2025–2026: A Four-Pillar Bazi Deep-Dive Into the Group's Collective Destiny

1 · Hook — Three Lines That Stop the Scroll

The Day Pillar(日柱) sits at 庚戌, a metal axe buried in dry earth — raw, compressed power waiting for a spark. The Year Pillar(年柱) carries 癸巳, Indirect Wealth(偏財) riding a hidden fire that quietly feeds the self. And the 2026 annual pillar arrives as 丙午 — blazing Hurting Officer(傷官) over Direct Officer(正官) — a combination classical texts call the "stage-fire configuration," the moment a performer stops rehearsing and starts burning.

2 · One-Line Verdict

Day Pillar 庚戌 (Friend/比肩 in the branches) meets a 2026 annual pillar of 丙午 carrying Seven Killings(偏官) in the stem and Direct Officer(正官) in the branch, supercharged by a Peach Blossom(桃花殺) and Goat Blade(羊刃殺) double-activation — this is a chart that earns its loudest applause precisely when the pressure peaks.

3 · Classical Mechanics — Stems, Branches, Ten Gods, and Three Spirits

3a · The Four Pillars at a Glance

Pillar	Stem (天干)	Branch (地支)	Stem Ten God	Branch Ten God
Year 年柱	癸	巳	Hurting Officer 傷官	Seven Killings 偏官
Month 月柱	戊	午	Indirect Officer 偏印	Direct Officer 正官
Day 日柱	庚	戌	Friend 比肩	Indirect Officer 偏印
Hour 時柱	壬	午	Eating God 食神	Direct Officer 正官

The Day Master is 庚 metal — the sword, the bell, the stage rigging. 庚 metal craves fire to be forged and earth to be supported; this chart delivers both in abundance. Month branch 午 and Hour branch 午 form a double Direct Officer(正官) presence in the branches, anchoring institutional recognition. Year stem 癸 as Hurting Officer(傷官) injects creative disruption from the very root of the chart — the natal identity is built on artistic rule-breaking.

3b · Ten-God Interplay

Eating God(食神) at the Hour stem 壬 is the performer's voice: fluid, generous, audience-facing. Classical theory holds that Eating God feeding into a strong Day Master generates "talent overflow" — creativity that cannot be contained by a single medium. For a group whose discography spans hip-hop, art-pop, and orchestral balladry, this resonates structurally.

Indirect Officer(偏印) at both Month stem 戊 and Day branch 戌 creates a protective intellectual layer. 偏印 absorbs knowledge and converts it into instinct. Two instances of it in the chart suggest a collective that learns from adversity faster than peers — hiatus, military service, industry pressure all become fuel rather than brake.

Hurting Officer(傷官) at Year stem 癸 opposing the Direct Officer(正官) cluster is the chart's central tension. 傷官 and 正官 in the same chart traditionally signal friction with authority structures — labels, industry gatekeepers, national expectations — yet when the Day Master is strong enough to hold both, that friction becomes the creative engine. 庚 metal here is strong: it sits on 戌 earth (Indirect Officer 偏印 support), and the month branch 午 fire forges rather than melts it.

3c · Three Key Spirits (神殺)

Peach Blossom(桃花殺) appears at Month branch 午 and Hour branch 午 — double activation. In classical theory, 午 is the Peach Blossom branch for a 庚 Day Master born in a year containing 巳. Double 午 in month and hour positions means public magnetism is not incidental; it is structurally woven into career timing and daily output. The ARIRANG World Tour is not a coincidence — it is the chart expressing its Peach Blossom(桃花殺) at scale.

Goat Blade(羊刃殺) is present at the Day branch 戌 position (noted in the natal chart's branch layer). 羊刃 on the Day branch of a 庚 metal chart amplifies cutting power — competitive edge, physical intensity, willingness to push past comfort. For a performing group, this translates as the capacity to deliver 40-song setlists without visible fatigue. The shadow side is overextension; the 2026 세운 (annual pillar) 丙午 will test this threshold directly.

Moon Virtue Noble(月德貴人) appears at the Year pillar position, noted in the natal chart. 月德貴人 is a protection spirit associated with institutional backing and the ability to recover from public reversals. Its presence at the Year pillar — the root of social identity — suggests that even in cycles of Seven Killings(偏官) pressure, a structural safety net tends to appear. Think of it as the chart's insurance clause.

4 · Classical Authority

Zi Ping Zhen Quan (子平真詮, He Lian-Gu, Qing dynasty) states: "When Hurting Officer(傷官) and Direct Officer(正官) coexist in a chart of strong Day Master, the native does not destroy authority — they become the new authority." — 《子平真詮》卷三·傷官論

This single passage reframes BTS's entire institutional arc: the tension with HYBE structures, the military service debate, the UN speeches. The chart was never anti-establishment; it was always proto-establishment, building a new one.

5 · Modern Reading — ARIRANG Tour × 2026 Annual Pillar × Current Major Cycle

5a · 2026 Annual Pillar: 丙午

The 2026 세운 (annual pillar) arrives as 丙午 — stem 丙 fire as Seven Killings(偏官) against the 庚 Day Master, branch 午 as Direct Officer(正官). The natal chart already carries 午 in two positions; a third 午 in the annual pillar creates a 三午 (triple 午) resonance in the branch layer. Classical theory calls this "branch flooding" — the energy of that branch becomes impossible to ignore.

午 is fire, performance, noon-sun visibility. Triple 午 in 2026 means the group's public presence reaches a structural maximum. The ARIRANG World Tour, running across this window, is timed — whether by design or intuition — into the chart's loudest frequency.

Stem 丙 as Seven Killings(偏官) carries both risk and reward. For a strong 庚 metal Day Master, 偏官 is the opponent that sharpens the blade. World tours are logistically brutal; this pillar confirms the intensity. But 月德貴人 at the Year root and the double 偏印 in the natal chart provide the absorption capacity to metabolize that pressure.

The Goat Blade(羊刃殺) activated by the 2026 annual pillar's 午 branch meeting the natal 午 cluster signals peak competitive output — the performances most likely to be cited in retrospectives. The risk is physical and emotional overextension; the mitigation is the 偏印 intellectual buffer already embedded in the chart.

5b · Current Major Cycle (大運): 13th Year — 丙辰

The current major cycle (大운) runs through the 丙辰 pillar: stem 丙 as Seven Killings(偏官), branch 辰 as Indirect Officer(偏印). This is a cycle that simultaneously challenges the Day Master's authority and provides the intellectual resources to meet that challenge. 辰 earth contains hidden 乙癸戊 — wood, water, and earth — a storage vault of adaptive capacity.

The 大운 stem 丙 aligns perfectly with the 2026 annual stem 丙: a double Seven Killings(偏官) activation. In classical theory, when the major cycle and annual pillar share the same stem, the energy of that Ten God is "doubled and focused." This is not a casual year — it is the year the major cycle delivers its central thesis.

6 · Infographic Summary

[INFO_GRAPHIC]

╔══════════════════════════════════════════════════════════╗
║ BTS GROUP NATAL CHART — KEY VECTORS 2026 ║
╠══════════════╦═══════════════╦══════════════════════════╣
║ PILLAR ║ TEN GOD ║ ACTIVE SPIRIT ║
╠══════════════╬═══════════════╬══════════════════════════╣
║ Year 癸巳 ║ 傷官/偏官 ║ Moon Virtue Noble 月德貴人║
║ Month 戊午 ║ 偏印/正官 ║ Peach Blossom 桃花殺 ×1 ║
║ Day 庚戌 ║ 比肩/偏印 ║ Goat Blade 羊刃殺 ║
║ Hour 壬午 ║ 食神/正官 ║ Peach Blossom 桃花殺 ×2 ║
╠══════════════╬═══════════════╬══════════════════════════╣
║ 2026 세운 ║ 偏官(stem) ║ Triple 午 Branch Flood ║
║ 丙午 ║ 正官(branch) ║ Goat Blade 羊刃 Trigger ║
╠══════════════╬═══════════════╬══════════════════════════╣
║ 大운 丙辰 ║ 偏官(stem) ║ 偏印 Storage Vault ║
║ (13th yr) ║ 偏印(branch) ║ Double 丙 Focus ║
╚══════════════╩═══════════════╩══════════════════════════╝
VERDICT: Peak public visibility cycle. High output, high pressure.
Moon Virtue Noble(月德貴人) provides structural safety net.

7 · The Reversal — The Unexpected Twist

Here is what most practitioners miss: the Hour Pillar(時柱) Eating God(食神) 壬 is quietly the most powerful force in this chart for 2026.

Everyone focuses on the Seven Killings(偏官) 丙 in the annual pillar. But 壬 water Eating God(食神) in the Hour stem controls 丙 fire through the water-over-fire relationship (水剋火). The very stem that generates the most pressure — 丙 Seven Killings(偏官) — is structurally restrained by the Hour stem's Eating God(食神). This is the classical "Eating God Controlling Seven Killings(食神制殺)" formation, one of the most celebrated configurations in Four-Pillar theory.

What this means practically: the 2026 pressure cycle has a built-in release valve. The group's creative output — the music itself, the performances, the artistic decisions — is the mechanism that converts Seven Killings(偏官) pressure into productive energy. The ARIRANG World Tour is not just a commercial event; structurally, it is the chart's pressure-management system operating at full capacity.

The Peach Blossom(桃花殺) double-activation in the natal chart means the audience is the catalyst. The larger the crowd, the more efficiently the 食神制殺 mechanism operates. Stadiums, in this reading, are not optional — they are the chart's preferred operating environment.

8 · Three-Line Summary

The 庚戌 Day Master chart carries a rare 食神制殺 formation that converts peak-pressure cycles into peak-performance cycles. The 2026 annual pillar 丙午 triggers triple 午 branch flooding, Goat Blade(羊刃殺) activation, and double Seven Killings(偏官) focus — yet the Hour stem 壬 Eating God(食神) holds the architecture together. The ARIRANG World Tour lands in the chart's structurally loudest window; the classical indicators suggest this tour may define the group's legacy more than any prior cycle.

9 · Go Deeper

Want to run your own Four-Pillar chart against the 2026 annual pillar?

👉 runartree.com — generate your full Bazi natal chart, identify your active Ten Gods, and see which 2026 triggers apply to your personal configuration.

This article is written for educational and entertainment purposes. Four-Pillar Bazi analysis reflects classical theoretical frameworks and does not constitute personal fortune-telling, financial advice, or verified prediction of future events. Individual outcomes vary based on free will, environment, and factors beyond any astrological system.

Bazi interpretation. Not medical/legal/investment advice.

The Stars Were Always Watching: Heo Nam-jun's Bazi Chart and the 2026 Surge Nobody Saw Coming

HYUN SOO LEE — Thu, 30 Apr 2026 13:00:00 +0000

The Stars Were Always Watching: Heo Nam-jun's Bazi Chart and the 2026 Surge Nobody Saw Coming

1 · Hook — Three Lines That Stop the Scroll

The Day Pillar(日柱) reads 辛酉 — a razor-edged metal blade sitting on its own mirror. The Month Pillar(月柱) carries 戊午 with 偏官 pressing down from above and 羊刃殺(Goat Blade) burning underneath. And the 2026 annual pillar drops 丙午 directly onto that same axis — a second flame landing on an already-lit fuse.

Eight days before My Royal Nemesis premieres, the chart is already screaming.

2 · One-Line Verdict

Day Pillar 辛酉(比肩·비견), anchored by a 正官(Direct Officer) year stem in 2026, converging with the Grand Luck(大運) stem 甲(正財), signals a window in which public recognition and material reward arrive together — not separately, not later.

3 · Bazi Mechanics — Reading Every Layer of the Chart

3-a · The Four Pillars at a Glance

Year Pillar(年柱) 癸酉
Stem 癸 = 食神(Eating God) / Branch 酉 = 比肩(Friend).
The 食神 sitting on the year stem is the classical marker of creative output that earns its own audience. 癸 water feeds the Day Master 辛 metal gently, giving the native an instinct for performing rather than forcing.

Month Pillar(月柱) 戊午
Stem 戊 = 正印(Direct Officer reading: the image shows 정인, i.e. Direct Resource) / Branch 午 = 偏官(Seven Killings).
The month position is the engine room of a chart. 正印 overhead means the native absorbs craft — training, technique, mentorship — with unusual retention. But the 偏官 in 午 below is the pressure valve: it creates urgency, competitive tension, the drive to prove something. The 羊刃殺(Goat Blade) tag on 午 sharpens that edge to a point. Goat Blade in classical texts signals intensity that, when channelled, becomes extraordinary focus; when unchecked, becomes self-sabotage.

Day Pillar(日柱) 辛酉
Stem 辛 = 比肩(Friend) / Branch 酉 = 比肩(Friend).
辛 sitting on 酉 is the strongest expression of the Day Master — metal on metal, the jeweller's blade. The 건록(Jianlu / Established Prosperity) tag on 酉 is significant: this is the 12-stage cycle peak of self-reliance. The native does not need external scaffolding to stand. He is the scaffold.

Hour Pillar(時柱) 甲午
Stem 甲 = 正財(Direct Wealth) / Branch 午 = 偏官(Seven Killings).
Birth time is recorded as 모름시 (unknown), so the hour pillar shown here is a system-generated placeholder. I will reference it only structurally, not predictively, to respect the data boundary.

3-b · Shinsal (神殺) Cluster — Three or More

The image surfaces four named 신살 across the four pillars:

Pillar	Shinsal (English + Hanja)
Year 午·月午	天乙貴人 Heavenly Noble — "heaven-sent guardian, descends when needed"
Year·Month	月德貴人 Monthly Virtue Noble — amplifies 관(官) luck via institutional channels
Month 午	羊刃殺(Goat Blade) — intensity, surgical precision, double-edged ambition
Month 午	도화살(Peach Blossom 桃花殺) — magnetism, public fascination, the audience-pull force
Year·Month	양인살(Goat Blade, confirmed second instance on 월주)

The 天乙貴人(Heavenly Noble) appearing in both year and month positions is not cosmetic. Classical Bazi holds that 天乙貴人 in the birth chart functions as a background rescue mechanism — the right person appears, the door opens at the last moment. For a performing artist, this often manifests as the audition that almost didn't happen, the director who took the call.

The 도화살(Peach Blossom 桃花殺) on the Month Branch 午 is the structural reason audiences find the native compelling without being able to articulate why. It is not romantic luck in isolation; it is charismatic gravity — people lean in.

3-c · The 辛·酉 Self-Rooted Structure

When the Day Stem and Day Branch share the same elemental identity (辛 = Yin Metal, 酉 = pure Yin Metal), the Day Master is described in classical texts as jianlu (建禄格, Established Prosperity Pattern). The native does not depend on resource stars to feel capable. This creates a particular performer archetype: one who can carry silence on screen, who does not overact to fill space, because the internal structure is already full.

4 · Classical Anchor

"辛金軟弱，溫潤而清。畏土之埋，樂水之盈。"
"Xin Metal is soft yet keen; it delights in water's nourishment and fears burial by earth."
— 《滴天髓》(Di Tian Sui / Drops of Heavenly Marrow), attributed to Jing Tu, annotated by Ren Tiequiao (任鐵樵), Chapter on Day Masters.

The 癸 water on the Year Stem is precisely the "water's nourishment" the classical text prescribes. The 戊 earth on the Month Stem is precisely the "burial" it warns against — yet here 戊 carries 正印, meaning the earth is structured resource, not smothering soil. The chart self-balances in a way that classical commentators would call 중화(中和, equilibrium).

5 · Modern Reading — Trigger × Annual Luck × Grand Luck

5-a · 2026 Annual Pillar 丙午

The 2026 세운(Annual Luck) presents:

Stem 丙 = 正官(Direct Officer) — the ten-god of public recognition, institutional legitimacy, and formal role assignment. For an actor, this is casting, contract, critical acknowledgment.
Branch 午 = 偏官(Seven Killings) — the same branch that sits in the Month Pillar. This is a 午午 self-penalty / reinforcement depending on chart context; here it amplifies the existing 偏官 pressure into a visible, external test.

The 正官 year stem landing on a 辛 Day Master is one of the cleaner recognition signals in Bazi. 辛 metal is governed by 丙 fire (丙 controls 辛 in the five-element cycle). When the controlling element arrives as 正官 rather than 偏官, it is discipline with reward, not punishment without cause.

5-b · Current Grand Luck (大運) 甲寅 — Age 31

Stem 甲 = 正財(Direct Wealth) — the ten-god of earned, stable material return. Not windfall; sustained income from recognised craft.
Branch 寅 = 正財(Direct Wealth) — double 正財 in the Grand Luck pillar is rare and structurally significant. It means the entire 10-year cycle (approximately ages 28–38) is oriented toward building something durable.

The 甲寅 Grand Luck also carries the 天乙貴人(Heavenly Noble) tag confirmed in the image. A noble star activated inside the Grand Luck window means the background rescue mechanism is on, not dormant.

5-c · Convergence Point — D-8 Before Premiere

My Royal Nemesis premieres in eight days from the date of this analysis. The 丙午 annual pillar is active. The 甲寅 Grand Luck is mid-cycle. The natal 도화살(Peach Blossom) on Month Branch 午 is being directly stimulated by the 2026 Branch 午. In Bazi, when an annual branch mirrors a natal branch carrying 桃花殺, public visibility tends to spike — not because of manufactured promotion, but because the native's natural magnetism is operating at a structural peak.

This is not a prediction. It is a pattern-recognition statement: the chart conditions in 2026 are among the most convergent in the native's recorded luck cycle to date.

6 · [INFO_GRAPHIC]

┌─────────────────────────────────────────────────────────────┐
│              HEO NAM-JUN  四柱命理  SNAPSHOT               │
├──────────┬──────────┬──────────┬──────────┬────────────────┤
│  年柱    │  月柱    │  日柱    │  時柱    │  2026 세운     │
│  癸酉    │  戊午    │  辛酉    │  甲午    │  丙午          │
│  食神    │  正印    │  比肩    │  正財    │  正官          │
│  比肩    │  偏官    │  比肩    │  偏官    │  偏官          │
├──────────┴──────────┴──────────┴──────────┴────────────────┤
│  KEY SHINSAL                                               │
│  天乙貴人  Heavenly Noble   → Year + Month position       │
│  月德貴人  Monthly Virtue   → Year + Month position       │
│  羊刃殺   Goat Blade        → Month Branch 午             │
│  桃花殺   Peach Blossom     → Month Branch 午             │
├─────────────────────────────────────────────────────────────┤
│  GRAND LUCK (大運) Age 31: 甲寅 — 正財 / 正財             │
│  2026 ANNUAL:  丙午 — 正官 / 偏官                         │
└─────────────────────────────────────────────────────────────┘

7 · The Reversal — What Nobody Mentions

Everyone fixates on the 도화살(Peach Blossom 桃花殺) as a charm indicator. The overlooked element is the 午午 self-encounter between the Month Branch natal 午 and the 2026 Annual Branch 午.

In classical Bazi, 午午 is classified as a self-penalty (自刑, zixing) — the same branch meeting itself. Self-penalties are not straightforward bad luck; they are amplifiers of whatever is already present. If the native is disciplined, the self-penalty accelerates output. If the native is scattered, it accelerates collapse. Given that the 甲寅 Grand Luck is 正財 dominant — structured, patient, craft-oriented — the 午午 amplification in 2026 is more likely to turbocharge the existing momentum than to derail it.

The 건록(Jianlu) tag on the Day Branch 酉 reinforces this: a self-reliant Day Master under a 正官 annual stem, inside a 正財 Grand Luck, facing a 午午 self-penalty that amplifies rather than destroys — this is the chart of someone who rises precisely when the pressure becomes unbearable for others.

8 · Three-Line Summary

The natal 辛酉 Day Pillar gives Heo Nam-jun a self-rooted, precision-edged structure that does not require external validation to function. The 2026 annual pillar 丙午 introduces 正官 — public recognition, formal legitimacy — at the exact moment a major drama role arrives. The Grand Luck 甲寅 wraps both in a decade of 正財 accumulation, suggesting that whatever visibility 2026 delivers is not a flash but a foundation.

9 · CTA

Want your own Four Pillars chart read with this level of structural detail?

→ runartree.com

Upload your birth data, receive a full Bazi analysis grounded in classical texts — not algorithmic guesswork.

Disclaimer: This article is written for educational and entertainment purposes only. Bazi (四柱命理) is a traditional East Asian interpretive framework and does not constitute a guarantee of any future outcome. No statements herein should be construed as financial, career, or personal life advice. All interpretations are probabilistic pattern readings, not deterministic predictions.

Bazi interpretation. Not medical/legal/investment advice.