SGK

AI-native builder from Korea.
Shipping agents, prompts, and playbooks built on Claude Code.
30-day public build in progress - follow along.

[SGK @sgkpartners]

Starting a 30-day Build in Public challenge.
Goal: Ship my AI-native Builder OS on @lemonsqueezy.

Day 1: Just signed up for LemonSqueezy.
Store approved. Now I need to build a sense of shipping.

Let's see if a solo dev from Korea can ship in English.

[SGK @sgkpartners]

Escalation rate went down week over week.
The others I am still calibrating.

The insight: you cannot improve autonomy by feel.
You improve it by deciding what counts as autonomous.

Metrics do not measure autonomy. They define it.

[SGK @sgkpartners]

I told myself the AI was getting more autonomous.
Week after week. Session after session.
I had no way to prove it.

Feeling isn't a metric. I needed numbers.

[SGK @sgkpartners]

The right frame: four rates.

Escalation - how often it stops to ask.
Recovery - when it loops, does it self-correct?
Cost per item - tokens and time per task done.
Loop hit - how often it drifts past 50 tool calls.

Same session. Four different answers.

[SGK @sgkpartners]

It runs full sessions now without interrupting me.

Progress reports at 3 compeltions, 2 hours, or 50 tool calls.
Silence after each report. Then it keeps going.

Autonomy isn't earned by asking less.
It's defined by listing what would never get auto-approved.

[SGK @sgkpartners]

I kept stopping the agent mid-run to confirm each step.
"Does this look right?"
"Should I continue?"
It felt careful. It was actually a bottleneck.

Every confirmation was me doing the agent's job.

[SGK @sgkpartners]

The fix wasn't telling it to ask less.

It was defining exactly when to stop.
Six conditions activate autopilot.
Then: silence means continue. Gates - not instructions - trigger stops.

The agent didn't need permission.
It needed a clear boundary for when not to ask.

[SGK @sgkpartners]

The audit runs every session now.
It finds real duplication. It flags reuse candidates.
It has never changed a single file.

Not because it's disciplined.
Because it can't.

You can't lecture an agent into restraint.
You can only remove the tools.

[SGK @sgkpartners]

I built an agent to audit my code.
Find duplication. Flag reuse candidates. Report only.

The prompt said: "don't modify files."
The agent interpreted that creatively.

Three sessions in, it was editing things I never asked it to touch.

[SGK @sgkpartners]

The fix wasn't a better prompt.

I removed Writhe, Edit, and Bash from the agent entirely.
Left only: Read. Grep. Glob.

Now it physically cannot modify a file.
No instruction needed. No forgetting possible.
The constraint lives in the toolset, not the text.

[SGK @sgkpartners]

I needed automation with stop conditions baked in.

The full chain: push, pr create, merge --squash, cleanup.
Hard-stops if:
- commit count > 3 or LOC > 500
- main push, --force, --no-verify
- quality gate score drops
- anything fails post-merge

Inside the gates, no asking.

[SGK @sgkpartners]

Every PR was the same six steps.
push, open GitHub, create PR, wait for checks, merge, delete branch.

I knew. I kept doing it anyway.
Automating "the boring part" felt risky.
What if it pushed to main? or merged broken code?

So I kept doing it by hand.

[SGK @sgkpartners]

I tried a shell script. One command, full flow.

It worked the first time.
Then I realized: no safety checks at all.
It pushed wherever the branch pointed.
It merged whatever was there.

"Automate the boring parts" is fine advice.
Until you automate yourself past the guardrails.

[SGK @sgkpartners]

@BoazWith Yes — and "the next session" is usually the next me.

Each decision gets four lines:
context, decision, consequences, alternatives rejected.

The rejected alternatives are where the trade-off lives.

[SGK @sgkpartners]

I came back to a Claude Code session I'd left open overnight.
The agent had no idea what we were doing.
Not because it forgot. Because the session ended.
Every time it does, we start from scratch.

[SGK @sgkpartners]

@BoazWith Plan loss, every time.

I can rebuild file state from git diff.
The why behind the next step isn't in the code - priorities, trade-offs.

PROGRESS.md and DECISIONS.md hold that.
The why outlives the what.

[SGK @sgkpartners]

The interesting part:

The cold starts didn't stop because I got better at explaining but I stopped relying on in-session memory at all.

Every decision, every learning - externalized.
The agent reads the state and writes the state.

Context persistence, not context injection.

[SGK @sgkpartners]

What I built instead: a session ritual.

On open: reads PROGRESS.md, DECISIONS, KNOWLEGE automatically.
On close: /wrap-up writes the state back. All three files.

The agent carries its own memory forward.
Not because I remind it. Because the ritual runs every time.