Forem: JessYT

Obsidian vs Notion: They Solve Completely Different Problems

JessYT — Fri, 15 May 2026 02:07:15 +0000

Obsidian vs Notion: They're Not the Same Tool

Both are "note apps." But the essence is different. Notion is a collaborative database, Obsidian is a personal knowledge graph. Where your markdown files live — that's where everything diverges.

Local vs Cloud
$0 vs $10/mo
As of 2026-05

01 · Essence: One is a DB, the other is files

Comparing these two on the same line keeps going sideways. Notion was built from day one as "a database teams use together," while Obsidian is "a graph view layered on top of a markdown folder on your disk." Where your data lives drives almost every difference.

	Notion	Obsidian
Category	Cloud-first · Collaboration	Local-first · Personal knowledge
Type	SaaS · Block-based DB	Local markdown · Graph
Storage	Notion servers	Your disk
Edit unit	Block	`.md` file
Strength	Team collab · DB	Personal PKM · Backlinks

Same category, different tools.

02 · Pricing: The solo cost gap is significant

For personal use, Obsidian is free, while Notion has a free-tier limit. The moment you need collaboration · DB features together, you're on Notion Plus ($10/user/month). "Same price" comparisons miss the starting point.

Personal free use, cost to unlock core features: ~~$10/mo~~ → $0 (Obsidian, personal use, forever free)

For personal use, Obsidian is fully free — app, plugins, and themes all included. You only pay for add-ons like cross-device Sync or web Publish.

03 · Four key metrics: Four numbers tell the whole story

Pricing · storage location · extensibility · collaboration — the four metrics that most often split note-tool decisions. Just figure out which metric matters most in your workflow and the choice almost makes itself.

Personal monthly cost: $0 (Obsidian free)
Storage location: Local (direct .md files)
Plugin count: 2000+ (community market)
Realtime collaboration: Limited (Notion wins)

04 · Fit — Notion is the answer if…

You need real-time edits on the same page with your team — comments · permissions · co-editing are Notion strengths
You need DB · Kanban · Calendar inside the doc — notes themselves act as databases
Web sharing · publishing is your default workflow — Publish gives you a share URL in one click
You write and review often from mobile — iOS · Android apps are polished
You want to grab from the template marketplace — CRM · wiki · project management out of the box

05 · Fit — Obsidian is the answer if…

Your notes need to outlive the next 10 years — .md files don't care if a service shuts down
You want backlinks · graph to connect knowledge — PKM · Zettelkasten workflow
Local-first — you avoid cloud dependence — sync via Git · iCloud · Dropbox, anything works
You write text only; heavy media lives elsewhere — the editor itself is light and fast
You customize your workflow with plugins — Dataview · Templater · QuickAdd, etc.

06 · Decide it in one line

Even if these two look similar, migration isn't simple. One thing to flag before you move:

Migration Pitfall

"I moved from Notion to Obsidian and all my DBs broke."

Cause: Notion's DB · relational properties don't map 1:1 to markdown. Plain notes move over fine, but pages where relation · rollup · formula are the core have to be rebuilt with Obsidian's Dataview plugin to behave equivalently. Sorting out "does this page actually need DB features?" before migrating cuts the cost dramatically.

The decision rule fits in five lines.

30-second decision guide

Team views it together → Notion (realtime collab · permissions · DB are the wins)
Solo, archive forever → Obsidian (local .md = no lock-in)
Frequent web publishing · external sharing → Notion (Publish = instant share URL)
You want to link and connect concepts → Obsidian (backlinks · graph view at the core)
Using both is also valid → Split roles (sharing = Notion / personal archive = Obsidian)

"Choosing a note tool isn't a feature comparison. It's choosing who holds your data."

— ediblog · Devtools Daily

These two are safest treated as role split, not competitors. Sharing on Notion, lifelong archive on Obsidian.

References

Notion Official

Obsidian Official

Related

ediblog — Devtools series

Disclaimer: Pricing · feature info as of 2026-05 official pages. No ads · no affiliates.

Originally published at jessinvestment.com.

Original with full infographics and visual structure: https://jessinvestment.com/obsidian-vs-notion-they-solve-completely-different-problems/

5 Token-Saving Habits From 3 Months With Claude Code

JessYT — Fri, 15 May 2026 02:01:32 +0000

5 Token-Saving Habits From 3 Months With Claude Code

EDIBLOG · Phase 2-1 · 3-Month Retrospective

Hi, I'm Eddie. After 3 months running blog automations, I settled on 5 token-saving habits. Honestly — I broke each one at least once before they stuck. This is the first deep dive I promised in the CLAUDE.md memory index post.

The 5 habits: /compact, agent split, /clear, CLAUDE.md split, 3 Skills.

01 — `/compact`: press it on the alert, judge by the next answer

Bottom line. I learned /compact fires when the context alert appears. The way I see it, it summarizes and compresses the conversation to free up token space. It is not lossless.

My take after 3 months: "Sometimes I lose things. When critical info disappears, the next answer can go off the rails."

My pattern — see the alert, run /compact, ask one question, and if it looks wrong I /clear and restart. No blind trust.

I think being honest about limits is the better move. I accepted that compaction is not lossless. Right after a critical code change, I now habitually restate the key facts before compacting.

# See the alert → /compact (first attempt)
[Claude] context window 80% used. /compact recommended.
$ /compact
[Claude] Compaction done — 60% token space recovered.

# Immediate one-line check after compacting
$ "Show me the contents of [key file] you just worked on"
# If clean, continue. If loss detected, /clear and restart

02 — Important work goes to a separate agent, not main

Bottom line. The second pattern, in my view, is role separation. I run main Claude as the coordinator and throw detail work to sub-agents.

My separation rule: "Anything I consider important — code review, benchmarking, post quality control — doesn't touch main Claude. Dedicated agents only."

I see two payoffs. Main context stays protected + only the final output of the detail work surfaces back to main. The biggest win is that reading a huge document once doesn't eat main context.

I keep 4 custom agents as one-pager markdown files under .claude/agents/:

monetization-analyst — Monetization analysis — VSD Pro · jessinvestment stage checks
opportunity-ranker — Opportunity ranking — sort next-sequence candidates
dev-finance-explorer — Dev × finance crossover — post idea discovery
asset-health-checker — Asset health check — jobs · blog operations status

On top of that, there's the /review slash command and the weekly weekly-blog-review job (6-AI panel for post quality). This was the single biggest token-saving move.

# Don't ask main Claude
$ Task(opportunity-ranker, "rank the next 10 post idea candidates")
# → sub-agent works in a separate context, only the result returns to main

# Main plays coordinator only
# Heavy analysis / 6-AI panels / benchmarking all go to separate agents

03 — `/clear`: not compression, full reset

Bottom line. Third, I actively use /clear.

My timing rule: "When the context completely shifts, I /clear and rebuild from scratch."

A typical example for me — finishing real-estate blog work and switching to debugging the trading system. I realized mixing the two contexts causes incidents.

I see the two tools as different roles. /compact is compress, /clear is full empty. After clear, the first message reloads only CLAUDE.md and I rebuild context from there.

This was a bit counterintuitive: clear isn't wasteful — NOT clearing is more expensive in most cases. Without clearing, every turn has to spend tokens replaying the entire prior context.

# /clear if you hit ANY of these
[ ] Complete domain switch (real-estate → trading system, etc.)
[ ] Answer feels off even after /compact (compression loss)
[ ] Conversation getting long, answers slowing down (context bloat)
[ ] Moving to another blog · project (separate CLAUDE.md folder)

# 1+ above → don't hesitate, /clear
# Clear, reload CLAUDE.md, restart clean

04 — Slim CLAUDE.md, move the rest to side files

Bottom line. The fourth is the CLAUDE.md diet.

My split rule: "Only what's needed every task lives in CLAUDE.md. Everything else is request-specific — that's how you save tokens."

The reason is clear to me. CLAUDE.md is auto-loaded every session. Every line in there spends tokens every time. The conclusion: anything you rarely look at has to come out.

My actual split structure:

File type	Examples
Main CLAUDE.md (auto-loaded every session)	`automation/CLAUDE.md` — ops rules, schedules, incident log
Side files (loaded only on request)	`real-estate/_series_guide.md` · `ediblog/SKILL.md` · `docs/INFRA_2026_05.md`
Archive (one-line index only)	`CLAUDE-archive-2026-04.md` — old incident log moved out

I split old incident logs into CLAUDE-archive-2026-04.md and kept only a one-line index in main. The main file had been swelling past 1,000 lines — you can feel the relief. To me, this is the heart of the main-slim pattern.

# Main CLAUDE.md (currently ~80 lines)

## 5. Incident log (learnings)

| Date | Incident | Action |
|---|---|---|
| 2026-05-09 | 4 publish failures + telegram loop | 4 self-recovery layers added |

> 10 incidents from 2026-04-14 ~ 2026-04-18 moved to `CLAUDE-archive-2026-04.md` §A
> 8 incidents from 2026-04-21 ~ 2026-05-04 moved to `CLAUDE-archive-2026-05.md` §A
> Main keeps only post-05-05 incidents

05 — 3 skills, loaded only on trigger

Bottom line. The last one, in my view, is skills. I keep 3 custom skills under automation/.claude/skills/.

add-launch-job — Auto-triggered when adding a new LaunchAgent job. Checks plist TCC policy · FD limit 3-layer defense. Used heavily this past week alone creating 5 new jobs.
blog-style-guide — Auto-triggered on post writing · review. Applies 9 base patterns + 4 evolved patterns + reviewer gate. Managed in one place across 4 daily-publishing blogs.
captcha-recovery — Auto-triggered on captcha · session corruption. Telegram relay + zombie Chrome cleanup. Rare but mandatory when it hits.

I couldn't measure the split effect quantitatively. My read: inline = main CLAUDE.md swells past 1,000 lines and gets fully loaded every session. Split = main keeps a one-line index, and SKILL.md only loads when triggered. I estimate ~30% main-token savings.

~30% main tokens saved (estimated, not measured)
3 custom skills (add · style · captcha)
1 rule-change point (one SKILL.md)

---
name: blog-style-guide
description: 9 writing patterns + reviewer gate thresholds for blog post
  writing · review · publishing in the automation project. Trigger on
  ediblog · jessinvestment · luna-pick · jesslab publishing
  tasks or post quality review requests.
---

# Automation project blog style guide
...

# When Claude matches keywords like "write this post" / "review" / "before publishing"
# Auto-trigger → load SKILL.md → apply 9 patterns

Coda — If I had to nail it in one line

Token saving isn't about tools — it's about deciding how much to pin in main.

— Eddie · Phase 2-1 wrap

All 5 only stuck after I broke them at least once each. I'd recommend looking at what info you actually need every session before memorizing tools. That, I realized, is the essence of token saving.

Phase 2 · next deep dives

2-2 Slash commands deep dive — /run-daily differences across 5 blogs (soon)
2-3 3 custom skills deep dive — why I built them · structure
2-4 CLAUDE.md operations — how the incident log accumulates

Every line that auto-loads is a cost. I only pin what every session actually needs.

Sources · References

Claude Code Official

Series index

Can't leave my desktop — Claude Code 3 months, 6 patterns (Phase 1, series index)

Disclosure: Personal 3-month retro. No ads, no affiliates.

Original with full infographics and visual structure: https://jessinvestment.com/5-token-saving-habits-from-3-months-with-claude-code/

How a Telegram Bot Lets Me Run My Blog From Anywhere

JessYT — Fri, 15 May 2026 01:55:46 +0000

AI Cut My Writing 90% — But I Still Couldn't Leave My Desktop

Hi, I'm Eddy. I'm writing this post from abroad, replying only through Telegram. After two months of running this setup, my conclusion is simple: wire Claude Code to a Telegram bot and you can basically leave your desktop off.

4 sparks that pushed me to build the bot

Bottom line. I hit a moment where being glued to my desktop felt wildly inefficient. Four things had stacked up at once.

Captcha block — jobs stall. If a Tistory captcha pops up while I'm out, I can't see it. Publishing halts and I have no way to know.
Overnight failures — caught late. If a job fails at 3am, I only find out the next morning. A whole publish slot, gone.
Daily review — stuck at the desk. Every publish meant coming back to the desk for review. No freedom to actually leave the house.
Ideas — lost on the go (biggest). Topics and ops ideas that hit me out walking died as memos. No way to apply them in the moment.

The biggest one for me was #4. I had to break the memo-it-then-forget pattern. When a topic hit me on the street, I wanted to apply it right there.

4 moments where the bot really earns its keep

After installing the bot, four moments delivered the biggest payoff. These four, I'd argue, are the bot's real value.

Moment 1 — Captcha reply: Claude Code ships captcha screenshots to Telegram

When a captcha image lands in Telegram, I reply with the text. The bot auto-fills it and publishing continues. Jobs don't stall even while I'm out. One glance at my phone, one-line reply, done.

🔒 Tistory captcha detected
Time: 2026-05-10 14:22 KST
Post: AI Update — Claude Mythos Preview...
Session: jessyt

[Image attached — captcha]

Reply with just the captcha text.
No reply within 30 min → auto-abort + draft preserved.

Moment 2 — Interview from abroad: I'm writing this very post via Telegram interview

The bot fires 5–6 questions per topic and I just answer. Those answers become a first-person draft as-is.

I've written posts this way from planes, airports, cafés. No desktop needed.

🤖 BOT: Today's topic — "Running 30 Claude Code slash commands"
        Q 1/6: What pushed you to make your first slash command?

👤 ME : Got tired of copy-pasting the same prompt every time. Once I
        forgot a line and the output came back completely different.

🤖 BOT: Q 2/6: How many are you running now? Any naming convention?
        ...

Interview answers → first-person draft conversion prompt:

# interview-to-draft.md (Claude Code slash command)
---
description: "Convert Telegram interview answers into a first-person draft"
---

Take the interview Q&A below and write:
1. Don't quote answers verbatim — restructure as first-person flow
2. Match voice.md tone ("I tried ~", "I found ~")
3. CLAUDE.md soft rules — 80%+ first-person / cite external sources
4. Apply blog-style-guide §A~§Q
5. Save HTML to drafts/ + send Telegram preview alert

Moment 3 — Overnight failures: "3am failures? I'm just going to sleep through them."

24/7 alerts don't mean 24/7 response capability — I learned that the hard way.

I decided to just pass on overnight failures. Batch them the next day. Accepting my own limits turned out to be the healthier ops mode.

Moment 4 — Instant feature & quality tweaks: the second an idea hits, I instruct the bot

When Claude Code ships a good new feature, I push the apply-it instruction through Telegram immediately. Post quality? I grade and decide through the bot too.

The biggest shift was getting an apply-on-the-spot cycle. Fastest way I found to escape the procrastinate-then-forget loop.

My alert policy evolved with the scale of automation

When I first installed the bot, every job result became an alert. At the time I was running 7 blogs, and so many alerts came in that I stopped looking altogether.

Now I've trimmed alerts down to just two streams.

⚠ Failures batched and reported twice daily. No instant alerts — I'm going to be asleep at 3am anyway.
📥 Drafts trigger instant alerts every time. That's the exact moment my action (quality review & publish) is needed.
✕ Successes & progress = no alert — "still running fine" pings are just noise.
💡 Once I scaled ops down to one focus, alerts stabilized on their own. Cutting automation, I learned, is also a skill.

Alert taxonomy:

Event	Alert policy	Why
Job failure (publish)	Batched 2x/day	I sleep at 3am
Captcha detected	Instant	Reply needed in 30 min
Draft saved	Instant	User review + publish needed
Success / progress	No alert	"Still running" = noise
Captcha quota near	Instant + pause publish	Block captcha pile-up
Session corrupted	Instant + alert channel	Recovery procedure needed

How my way of working changed

Comparing before and after the bot, the biggest change is being able to operate, write, and decide anywhere, anytime.

Before — desktop hostage (stuck at my desk daily):

📍 Back at the desk daily for review
🖥 Monitor on 24/7
⛔ Captcha mid-outing stalls publishing
💭 Ideas become memos, then evaporate

After — bot integrated (phone is enough):

📱 Desktop barely opens
🌍 Operating & writing from abroad
⚡ Quality & ops decisions instant
💡 Apply ideas on the spot (no evaporation)

The biggest payoff, for me, is being able to make quality and ops decisions instantly. Turning the monitor off and saving electricity is a side effect at best.

My setup started with one line

I didn't actually write a single line of code myself. I gave Claude Code one line of instruction and it worked.

First prompt: "Make it so I can respond via Telegram!" — the exact one line I first typed.

That's the only line I typed. Claude Code walked me through bot token issuance, then dropped in the alert module, captcha image relay, and the interview polling loop, one step at a time.

#!/usr/bin/env python3
# lib/telegram_send.py — alert module dropped in from the first one-liner

import os, requests

def send(message: str, category: str = "blog") -> None:
    token = os.environ['TELEGRAM_BOT_TOKEN']
    chat_id_map = {
        'blog':     os.environ.get('TELEGRAM_CHAT_BLOG'),
        'alert':    os.environ.get('TELEGRAM_CHAT_ALERT'),
        'briefing': os.environ.get('TELEGRAM_CHAT_BRIEFING'),
    }
    chat_id = chat_id_map.get(category) or os.environ['TELEGRAM_CHAT_ID']
    requests.post(
        f'https://api.telegram.org/bot{token}/sendMessage',
        json={'chat_id': chat_id, 'text': message},
        timeout=10,
    )

I didn't try to make it perfect from the start. I asked for one missing piece at a time and grew it. Starting with alerts, then captcha replies, interviews, ops instructions — I grew the cycle by iterating.

# lib/telegram_bot.py — publish review reply handling (excerpt)
COMMAND_ROUTER = {
    '/publish':    handle_publish_now,      # Publish immediately
    '/skip':       handle_skip_draft,       # Keep as draft, don't publish
    '/cancel':     handle_cancel_draft,     # Delete post + return to queue
    '/schedule':   handle_schedule,         # /schedule 14:30 → schedule at 14:30
}

def handle_telegram_reply(msg):
    """30-min timeout polling — review possible even while out."""
    cmd = msg.get('text', '').strip().split()[0]
    handler = COMMAND_ROUTER.get(cmd)
    if handler:
        return handler(msg)
    # No command match → treat as captcha reply
    return handle_captcha_answer(msg)

Bot feature evolution timeline:

Day 1 — Alert module (publish success/failure alerts)
Day 7 — Captcha image relay + reply handling
Day 14 — Interview polling loop (5–6 Qs → answers → draft)
Day 21 — Batched failure reports 2x/day (kill instant alerts)
Day 30 — Ops instruction reply handling (/publish /skip /schedule HH:MM)
Day 45 — Quality review gate (pre-publish card + reply branch)
Day 60 — Alerts compressed 7 streams → 2 (normalized)

You don't need every feature on day one — that was my biggest lesson.

If I had to land it in one line

Build the environment that lets you work anywhere, anytime — first. That's how your hours getting smarter alongside Claude Code actually grow.

— Eddy, replying from abroad

I realized the desktop isn't something to keep on — turning it off is the right answer. That's how your time working with AI grows.

The essence of automation isn't working 24 hours — it's that work keeps rolling even when you go to sleep.

Sources & References

Tools used

Series & Related posts

5 real Claude Code tips I learned in 2 months (previous post)
Context Engineering 3-file pattern — Claude writing in my voice
How to fully use Claude Code memory

Disclaimer: My personal 2-month ops log. No ads, no affiliates.

Originally published at jessinvestment.com.

Original with full infographics and visual structure: https://jessinvestment.com/how-a-telegram-bot-lets-me-run-my-blog-from-anywhere/

Claude Finance: Anthropic Packages Wall Street Workflows Into 10 Agents

JessYT — Thu, 14 May 2026 02:09:05 +0000

Claude Finance: Anthropic Packages Wall Street Workflows Into 10 Agents

On May 5, Anthropic launched Claude Finance — its first domain-specific plugin bundle. Investment banking, private equity, and wealth management workflows packaged as 10 agent templates, shipped simultaneously as Claude Cowork and Claude Code plugins plus a Managed Agents Cookbook. A clear inflection point: from the horizontal-LLM era to the vertical-domain-package era.

Launched May 5
10 agent templates
5 domains
MS 365 integration
Adoption time: days, not months

01 — From "horizontal LLM" to "domain package"

Claude used to be horizontal. Each team built its own domain workflows with custom prompts and context. Claude Finance flips that — Anthropic ships the buildout itself as a package.

	Before	Claude Finance
Model	Horizontal	Vertical
Shape	General-purpose LLM	10 agent templates
Build work	Teams build domain workflows themselves	Ready-to-run reference architecture
Time	Months	Days

02 — 5 domains, 10 agent templates

Here are the five domains Anthropic announced, with the headline task for each. Wall Street's most time-consuming work — pitchbook drafting, KYC file screening, month-end close — is squarely in the crosshairs.

Financial analysis — Market and competitor research, financial modeling. The automation baseline for any analyst workflow.
Investment banking — M&A deal document review, pitch deck drafting. The biggest headcount sink on the IB floor.
Equity research — Earnings transcript parsing, model updates. Picks-and-shovels for earnings season.
Private equity — Financial data review, scenario modeling. Aimed at deal sourcing and diligence.
Wealth management — Portfolio analysis, rebalancing recommendations. Per-client advisory automation.

03 — Each agent = skills + connectors + subagents

"Each agent template packages three things: skills, connectors, and subagents."

skills = domain knowledge and task instructions
connectors = governed data access (Bloomberg, internal DBs, etc.)
subagents = dedicated models for subtasks like comparable-company selection or methodology validation

In other words, it's not a single LLM call but a multi-agent collaboration pattern, templated.

Three distribution channels shipped together: Claude Cowork plugin + Claude Code plugin + Managed Agents Cookbook. The Microsoft 365 (Excel, PowerPoint, Word, Outlook) add-in is wired in too, so work that starts in the model continues straight into the deck or sheet without re-explaining context.

5 domains (IB · Equity · PE · WM · Analysis)
10 templates (ready-to-run references)
3 components per agent (skills · connectors · subagents)
4 MS 365 add-ins (Excel · PowerPoint · Word · Outlook)

04 — Takeaway

"From horizontal LLMs to vertical domain packages — Anthropic's first domain plugin pointing straight at finance is the signal."

— jessinvestment, launch analysis

This isn't just another model release — it's a domain workflow shipped as a ready-to-run reference package. Watch for the next domain expansions (healthcare, legal, education).

Sources

Official (primary)

Disclosure: Analysis based on official announcement. No first-hand usage. No ads or affiliate links.

Canonical: https://jessinvestment.com/?p=511

Original with full infographics and visual structure: https://jessinvestment.com/?p=511

Claude Code Stops Pausing Every Turn: /goal, /loop, /batch, /background

JessYT — Thu, 14 May 2026 02:02:12 +0000

Claude Code Stops Pausing Every Turn: /goal, /loop, /batch, /background

Anthropic's official docs just bundled four new slash commands: /goal, /loop, /batch, /background. The old default — wait for user input every turn — just split into four autonomy modes: condition, interval, isolation, parallel. Here's what changed and when to reach for which.

4 autonomy modes
/goal — condition-based
/loop — v2.1.72+
/batch — parallel PRs
/background — v2.1.139+

01 · From "pause every turn" to "autonomous until condition"

Claude Code stopped at the end of every turn. You had to type "continue" over and over. Tasks like migrations that need N replies meant you couldn't step away. These four commands change that default assumption.

Default — turn-by-turn

Waits for user input every turn
1 migration = N inputs
Long task = stops the moment you leave

Autonomous — auto × 4

Condition · interval · isolation · parallel
Until condition met / re-run on interval
Detached session / 5–30 parallel PRs

02 · Four commands at a glance

The official docs spell out, per command, how the next turn starts and what stops it. Token usage and operational overhead are the axes that diverge most.

Command	Mode	Notes
`/goal`	CONDITION	Haiku eval, 4000 chars
`/loop`	INTERVAL	v2.1.72+, 1m–1h
`/batch`	PARALLEL	5–30 PRs, worktree
`/background`	DETACHED	v2.1.139+ agent view

03 · Autonomy has a price tag

"Running several sessions or subagents at once multiplies token usage."
— official docs

Key point: /batch spins up 5–30 background subagents simultaneously, multiplying token usage. It also requires a git repository — each subagent works in an isolated worktree, then opens a PR. /goal runs a fast eval model (Haiku by default) on every turn to check the condition, but the docs note that "eval tokens are negligible compared to main-turn spend."

/background processes stop after 1 hour of inactivity, but state persists on disk so claude respawn --all brings them back. /loop only runs while the session is open and auto-expires after 7 days.

04 · When to reach for each one

Recommended scenarios from the official docs:

/goal — Migrate a module until tests pass, implement a design doc until acceptance criteria are met, work the backlog until the queue is empty — anything with a clear stop condition.
/loop — Poll a deploy until it's done, watch a PR for new reviews, check a long-running build — anything that needs periodic re-checks. Omit the interval and Claude picks one between 1 minute and 1 hour.
/batch — Codebase-wide migrations and mechanical refactors like "migrate src/ from Solid to React." Auto-decomposed into 5–30 independent units, each landing as a worktree-scoped PR.
/background — Detach long-running tasks like "run the tests and fix what fails" so your terminal is free for other work. Track progress in the claude agents view.

These four aren't mutually exclusive. Set a /goal inside /background so the detached session runs autonomously until the condition is met, or use /loop to poll a /goal's progress on an interval.

"The era of pause-every-turn-by-default is over. Now you pick which of four autonomy modes fits the job."
— ediblog · release notes recap

This isn't just new features — Claude Code's execution model itself has branched. Map your work to the right autonomy mode ahead of time and you're set.

Sources

Primary · Official docs

Disclosure: Based on official docs. No first-hand usage report. No ads, no affiliate links.

Originally published at jessinvestment.com

Original with full infographics and visual structure: https://jessinvestment.com/?p=510

Claude Code Stops Pausing Every Turn: /goal, /loop, /batch, /background

JessYT — Wed, 13 May 2026 21:50:19 +0000

Claude Code no longer pauses every turn. /goal, /loop, /batch, /background

The official docs bundled four commands. /goal · /loop · /batch · /background — the default model of waiting for the user every turn just split into four autonomous modes: condition, interval, isolation, and parallel. Here's what changed and when to reach for which.

4 autonomous modes
/goal — condition-driven
/loop — v2.1.72+, interval-driven
/batch — parallel PRs
/background — v2.1.139+, isolated session

01 · From "pause every turn" to "autonomous until a condition"

Claude Code used to stop at the end of every turn. You typed "continue" each time. Migrations and other tasks needing N replies couldn't be left unattended. These four commands rewrite that default assumption.

Before — default behavior (turn-by-turn)

Waits for user every turn
1 migration = N inputs
Long jobs stall the moment you leave

After — autonomous runtime (auto × 4)

Condition · interval · isolation · parallel
Until the goal is met / on an interval
Out-of-session / 5–30 parallel PRs

02 · The four commands at a glance

The docs spell out, per command, how the next turn begins and what stops it. The biggest axes of difference are token cost and operational overhead.

Command	Mode	Notes
`/goal`	condition	Haiku eval, 4000 chars
`/loop`	interval	v2.1.72+, 1m–1h
`/batch`	parallel	5–30 PRs, worktree
`/background`	isolation	v2.1.139+ agent view

03 · Autonomy comes with a price tag

"Running several sessions or subagents at once multiplies token usage." — official docs

The point: /batch spawns 5–30 background subagents at once, so token spend multiplies. It also requires a git repo — each subagent works in an isolated worktree and then opens a PR. /goal runs a fast evaluation model (Haiku by default) every turn to check the condition, but the docs note that "evaluation tokens are negligible compared to main-turn spend."

/background pauses after 1 hour of inactivity, but its state lives on disk and can be resumed with claude respawn --all. /loop only runs while the session stays open and auto-expires after 7 days.

04 · Which command for which job

Recommended scenarios from the docs:

/goal — Migrate a module until tests pass, implement a design doc until acceptance criteria are met, drain a backlog until the queue is empty — anything with a clear stop condition.
/loop — Poll a deploy, watch a PR for review, check on long builds — anything you want re-run on a cadence. Omit the interval and Claude picks one dynamically between 1 minute and 1 hour.
/batch — Codebase-wide migrations and mechanical refactors like "migrate src/ from Solid to React." Claude auto-splits the work into 5–30 independent units, each producing a PR from its own worktree.
/background — Push long-running work like "run the tests and fix the failures" out of the foreground so you can use the terminal for something else. Monitor progress with the claude agents view.

These four aren't mutually exclusive. You can nest /goal inside /background so a background session keeps running until the condition is met, or use /loop to poll the progress of a /goal periodically.

"The era when pausing every turn was the default is over. Now you pick one of four autonomous modes instead."

This isn't just a feature drop. Claude Code's underlying execution model itself just forked. Map your work onto the right autonomous mode in advance and you're set.

References

Official docs (primary):

Disclosure: Summary based on official docs. No first-hand usage report. No ads or affiliate links.

Canonical: https://jessinvestment.com/claude-code-stops-pausing-every-turn-goal-loop-batch-background/

Original with full infographics and visual structure: https://jessinvestment.com/claude-code-stops-pausing-every-turn-goal-loop-batch-background/

Three Months With Claude Code: What 35 Jobs and 26 Killed Ones Taught Me

JessYT — Wed, 13 May 2026 14:15:09 +0000

Three Months With Claude Code: What 35 Jobs and 26 Killed Ones Taught Me

Bottom line up front. AI support cut 90% of my writing time. Three months in, I built 35 automation jobs and killed 26. Volume alone doesn't make money — that part I confirmed the hard way.

3 months in
35 jobs active
26 killed
90% writing time saved

01 · What I have to show for 3 months, in numbers

Start with the tangible stuff. This is the automation surface I've built up over three months. Every morning, launchd runs the lot without me touching anything.

35 LaunchAgent jobs (26 killed)
12 project folders (5 blogs + α)
3 custom skills (only SKILL.md loads)
19 slash commands (/run-daily & co.)

On top of that: 13 CLAUDE.md files (1 main + 12 per-project) and 3 hook scripts. Every job ships with a wrapper, plist, and log file — so the actual file count is well past 100.

02 · Five things that actually save tokens

In Claude Code, context tokens are the bill. After three months, these are the five habits that stuck.

/compact — the moment the context warning fires. When the alert pops, hit it immediately. Keeps the gist, drops the rest.
Split out agents — separate roles for detail and deep work. Main session is the coordinator; details go to a sub-agent. Keeps the context from getting polluted.
/clear — every time the task switches. Going from blog work to infra debugging? Clear, no exceptions.
Keep CLAUDE.md slim — only the must-reads. It auto-loads every session. Push the rest into separate files and reference them only when the task calls for it.
Skill split — load only SKILL.md. My three custom skills sit in their own files. The full text stays out of context until needed.

03 · The three I actually use every day

Out of 19 commands, 3 skills, and a pile of plugins, these are the three I genuinely reach for daily.

Rank	Tool	How	ROI
A · Daily publish	`/run-daily ×5`	per-blog `.claude/commands/run-daily.md`	edit one line → all 5 blogs pick it up
B · Writing quality	`blog-style-guide`	9 base patterns + 4 evolved patterns in one file	tweak the guide once → every post follows the new rule
C · Design	`frontend-design`	installed 4/26, generates v2 visual components	3–5 polished components per post, on demand

The frontend-design plugin in particular changed what I can ship. Before it, I was hand-rolling CSS and the readability suffered. Now Hero, VS, and impact blocks come out clean in one pass. Eleven days in, the lift in visual quality is immediate.

04 · Automation ≠ revenue — the hardest lesson

"I assumed automated posts would mean automated income. Three months later, it's the opposite."

Root cause: automation cuts repetition cost. Revenue is built on trust. You can ship 5 posts a day, but if every one reads like a textbook, readers click and bounce.

Look at the asset count again. 35 active + 26 killed. Those 26 are the ones I built on the assumption that volume alone would pay off.

Early assumption (26 killed jobs):

"Auto-publish daily"
Generic / textbook tone
Conversion flatlined

After the pivot (35 active jobs):

Experiment logs + lived experience
Drafts → my own review
Reads trending up

Automation cuts repetition cost. Revenue compounds from trust. Two completely different mechanisms — I had to kill 26 jobs to internalize that. Volume without trust is worse than zero posts.

05 · CLAUDE.md ≠ memory — keep them separate

Two different contexts auto-load every session. Mix them up and things break.

Criteria	CLAUDE.md (project file)	Memory (auto-memory)
Holds	Operating rules, publish rules, incident logs	Meta info, persona, where external systems live
Update freq	Often (every time something breaks)	Occasionally
Trust	High — source of truth for ops	Supporting — meta only

The split rule is simple. "This needs to work in the next session" goes in CLAUDE.md. "Who the user is, where they work" goes in memory. Don't trust memory for operating rules — always pin them in CLAUDE.md. I caused several incidents over three months by getting this wrong.

One more thing: don't put it in either place. Concrete values (cash balances, prices) or transient state. They go stale fast — push them to a file or a database instead.

06 · Pull quote

"You still need a human's lived experience. Trust beats volume. But AI support did cut 90% of my writing time."

— Eddie, 3 months with Claude Code

07 · Six follow-ups I'll go deeper on

This post is the index. Each topic gets its own case-study post next.

Token saving deep dive — each of the 5 habits, in practice
Slash commands deep dive — how /run-daily differs across 5 blogs
3 custom skills deep dive — why I built them, how they're shaped
Running CLAUDE.md — how I let incident logs accumulate
frontend-design plugin — the 30-day review
Hooks, memory, agents — the rest of the stack

Productivity and trust aren't substitutes. AI buys back the time. The human fills in the trust.

Disclaimer: personal 3-month retrospective. No ads, no affiliates.

Originally published at jessinvestment.com.

Forem: JessYT

Obsidian vs Notion: They Solve Completely Different Problems

Obsidian vs Notion: They're Not the Same Tool

01 · Essence: One is a DB, the other is files

02 · Pricing: The solo cost gap is significant

03 · Four key metrics: Four numbers tell the whole story

04 · Fit — Notion is the answer if…

05 · Fit — Obsidian is the answer if…

06 · Decide it in one line

References

5 Token-Saving Habits From 3 Months With Claude Code

5 Token-Saving Habits From 3 Months With Claude Code

01 — /compact: press it on the alert, judge by the next answer

02 — Important work goes to a separate agent, not main

03 — /clear: not compression, full reset

04 — Slim CLAUDE.md, move the rest to side files

05 — 3 skills, loaded only on trigger

Coda — If I had to nail it in one line

Sources · References

How a Telegram Bot Lets Me Run My Blog From Anywhere

AI Cut My Writing 90% — But I Still Couldn't Leave My Desktop

4 sparks that pushed me to build the bot

4 moments where the bot really earns its keep

Moment 1 — Captcha reply: Claude Code ships captcha screenshots to Telegram

Moment 2 — Interview from abroad: I'm writing this very post via Telegram interview

Moment 3 — Overnight failures: "3am failures? I'm just going to sleep through them."

Moment 4 — Instant feature & quality tweaks: the second an idea hits, I instruct the bot

My alert policy evolved with the scale of automation

How my way of working changed

My setup started with one line

If I had to land it in one line

Sources & References

Claude Finance: Anthropic Packages Wall Street Workflows Into 10 Agents

Claude Finance: Anthropic Packages Wall Street Workflows Into 10 Agents

01 — From "horizontal LLM" to "domain package"

02 — 5 domains, 10 agent templates

03 — Each agent = skills + connectors + subagents

04 — Takeaway

Sources

Claude Code Stops Pausing Every Turn: /goal, /loop, /batch, /background

Claude Code Stops Pausing Every Turn: /goal, /loop, /batch, /background

01 · From "pause every turn" to "autonomous until condition"

02 · Four commands at a glance

03 · Autonomy has a price tag

04 · When to reach for each one

Sources

Claude Code Stops Pausing Every Turn: /goal, /loop, /batch, /background

Claude Code no longer pauses every turn. /goal, /loop, /batch, /background

01 · From "pause every turn" to "autonomous until a condition"

02 · The four commands at a glance

03 · Autonomy comes with a price tag

04 · Which command for which job

References

Three Months With Claude Code: What 35 Jobs and 26 Killed Ones Taught Me

Three Months With Claude Code: What 35 Jobs and 26 Killed Ones Taught Me

01 · What I have to show for 3 months, in numbers

02 · Five things that actually save tokens

03 · The three I actually use every day

04 · Automation ≠ revenue — the hardest lesson

05 · CLAUDE.md ≠ memory — keep them separate

06 · Pull quote

07 · Six follow-ups I'll go deeper on

01 — `/compact`: press it on the alert, judge by the next answer

03 — `/clear`: not compression, full reset