Obsidian

23 articles on Obsidian — programs, tooling, and delivery on Petralian.

Related topics

Browse by format

Browse by topicObsidian

Showing 23 articles on Obsidian

Conference room before standup with a single clipboard on the table and chairs angled inward.
Hybrid

Session Bridge as the Standup File Agents Read First

Best forDelivery leads and program managers who want agents and humans aligned on sprint intent before standup, not after transcript archaeology

Standup worked for humans in the room. It never fed the next session. A short Bridge file after standup gives agents and teammates the same priority, blockers, and owners.

Continue reading →
Open research journal with abstract diagrams beside an organized workshop bench in morning light.
Hybrid

When Poe Is the Research Layer and Cursor Is the Build Layer

Best forAnyone who researches in Poe or other chat tools and wants file-grounded builds in Cursor without context bleed

I run open-ended research in Poe, promote decisions into files, then use Cursor to implement in the repo and vault. Splitting layers beats one chat for everything.

Continue reading →
Industrial conveyor belts move scheduled packets while a lit desk handles one open folder for judgment work.
Hybrid

n8n vs My Cursor and Obsidian System: Scheduled Automation vs Judgment Work

Best forOperators comparing n8n to a Cursor plus Obsidian harness who need a clear line between scheduled integrations and file-grounded agent judgment

I retired n8n last year for AI-coded microservices on petralian.com. Cursor plus Obsidian still owns judgment work. Here is when each layer wins.

Continue reading →
Smartphone with chat glow on an armrest and a laptop displaying a folder tree on a table.
Hybrid

OpenClaw vs Cursor in 2026: Ambient Messaging Agent vs File-Grounded IDE

Best forAnyone who read OpenClaw hype and uses Cursor who wants a clear comparison between ambient messaging agents and file-grounded IDE work

OpenClaw is my mental model for ambient agents on WhatsApp and Telegram. Cursor is where files, rules, and shipping live. Here is the 2026 split.

Continue reading →
Automatic memory carousel beside open wooden drawers of markdown files connected by a beam of light.
Hybrid

Managed Agent Memory vs Files You Control: A Strategic Hybrid

Best forAnyone evaluating Mem0 or similar managed memory who also keeps Obsidian or git markdown and wants a clear hybrid rule instead of vendor lock-in

Mem0 and managed memory layers promise automatic recall. File harnesses promise portability. I use both lanes deliberately — not as a single winner.

Continue reading →
Cinematic 16:9: magnifying glass over a faint chat transcript layer floating above a solid leather notebook labeled only by texture, amber desk lamp, cool shadow.
Hybrid

Cursor Conversation Search vs a Bridge File: Where Session Memory Should Live

Best forAnyone relying on Cursor chat search who still loses thread between sessions and wants a durable handoff file without rebuilding the whole vault

Cmd+K transcript search finds what was said. A Bridge SSOT file holds what still matters. Here is when to use each and why files win for handoff.

Continue reading →
Cinematic 16:9: a single desk lamp illuminates a week planner board with six soft abstract mode tiles (thought bubble, handshake, notebook, calendar, wrench,...
Hybrid

One Agent, Many Workflows: What Cursor Customize Is For (Beyond Coding)

Best forAnyone who uses AI across study, business, and personal work and wants one customized agent interface instead of a pile of chat tabs

Cursor Customize is how you shape one agent for brainstorming, consulting, blogging, shipping, and life admin - then hand off between phone and desk without restarting from zero.

Continue reading →
Cinematic 16:9: macro of interlocking brass gears beside a leather notebook and a phone face-down, warm rim light suggesting a closed loop, no logos, no read...
Hybrid

Skills, Hooks, and Orchestration: Cursor Customize With an Obsidian Memory Loop

Best forReaders who already get work modes and want the Customize mechanics plus Obsidian/mobile handoff without a full wiring handbook

The deep dive on Cursor Customize mechanics that matter: skills, hooks, commands, subagents, MCPs - plus the Obsidian memory loop and mobile-to-desktop handoff.

Continue reading →
Cinematic 16:9: editorial desk with a manuscript stack beside a slim bridge notebook and a laptop edge in soft morning light, copper lamp glow, no logos, no ...
Hybrid

Cursor Customize for Blogging and Project Memory

Best forWriters and operators who want AI help on drafts without losing voice, publish control, or session continuity

Customize Cursor for Petralian-style blogging and project memory: voice rules, draft folders as publish gates, and Bridge/session notes so work continues after the chat ends.

Continue reading →
Cinematic 16:9: night train window with soft bokeh city lights, a notebook and phone on the tray table catching warm cabin light, sense of ideas in transit, ...
Hybrid

Cursor Customize for Brainstorming and a Personal Agent

Best forAnyone whose idea chats and life-admin chats keep contaminating each other

Use Cursor Customize so brainstorming stays exploratory and your personal agent stays private - without mixing life admin into public drafts.

Continue reading →
Everyday desk with laptop open to a workspace beside folders for study, work, and personal projects, warm natural light, no logos or readable text.
Hybrid

Is Cursor Only for Developers? A Better AI Interface for Anyone With Files

Best forAnyone outgrowing ChatGPT tabs who wants file-grounded AI that remembers your rules across projects, semesters, jobs, and side work

Cursor is sold as a coding IDE. I use it as a governed agent for writing, research, commerce, job search, client work, and code when needed. The win is file-grounded memory, not syntax highlighting.

Continue reading →
Desk with one labeled Obsidian notebook feeding multiple project folders on a laptop screen, warm editorial lighting, no logos or readable text.
Hybrid

How I Run Cursor With One Obsidian Brain Across Many Projects

Best forAnyone running Cursor across multiple contexts who wants one external memory system without rebuilding rules per folder

I stopped copying AI rules into every engagement. One Brain vault, native file reads, hooks, and a sync script align personal site, Shopify app, job applications, and client work — one memory system for program delivery.

Continue reading →
Cinematic 16:9: three translucent drawers labeled Repo, Brain-Pack,
Hands-on

Agent Harness Memory Loop — Four Tiers, Feedback Loop, and Load Gates

Best forPractice leads connecting file memory, Obsidian, and agent loops across engagements

External memory is four tiers in practice — short-term, operational, evergreen, and a feedback loop hardened into rules and footers. The harness gates when each tier loads so you keep control without token bloat.

Continue reading →
Cinematic 16:9 low-angle shot: two translucent IDE panes floating in
Hands-on

From VS Code Copilot to Cursor: What Changed in My AI Workflow

Best forPractice leads comparing Copilot and Cursor for governed agent workflows

Copilot had the same footer spec but dropped it on long chats. Cursor keeps it with alwaysApply rules, optional hooks, and a v3.1 mode-based Response Footer Contract.

Continue reading →
Desk with layered notebooks and a laptop showing a linked note graph for session continuity.
Hybrid

External Memory Series: A Practical Guide to AI Session Continuity

Best forProgram leads and knowledge workers adopting file-based memory for AI-assisted work — start here for the series map

Chat is not memory. This series explains a file-based external brain for builders and leaders—four layers, hooks, and why it beats hoping the model remembers.

Continue reading →
Calm home office desk with an open Obsidian-style linked note graph
Hybrid

Beyond Chat History: Using Layered Obsidian Memory for Personal Productivity

Best forKnowledge workers layering Obsidian memory beyond a single chat thread

The same three-layer memory stack used for shipping code works for strategic work, client engagements, and cross-tool AI—short chat, operational handoffs, evergreen notes, and explicit feedback.

Continue reading →
Editorial overhead photograph of a developer desk with three labeled
Hands-on

Three Layers of External Memory for AI-First Development

Best forPractice leads implementing layered external memory for agent-assisted delivery (Playbook)

Chat context is not memory. A three-layer file system—session, operational, evergreen—plus hooks and git automation is how I keep production codebases coherent across hundreds of agent sessions.

Continue reading →
Editorial photograph of a printed runbook and decision log on a conference
Hybrid

Why Deliberate File Memory Beats Hoping Agents Remember

Best forTeams adopting governance for file-based agent memory instead of hoping context sticks

Chat memory is opaque and ephemeral. Deliberate files give audit trails, solo-shipping continuity, team handoffs, and survival when models or tools change.

Continue reading →
Editorial desk with two diagrams side by side on paper—one a simple
Hybrid

Why File Memory Beats the Three-Layer AI Diagram

Best forLeaders choosing file memory for governed AI programs over diagram-perfect architecture

The popular STM / LTM / feedback diagram optimizes in-model memory. A file-based external brain optimizes audit, handoff, and tool churn. Here is when each design wins—and why I chose files.

Continue reading →
A clean editorial illustration of a writer's Obsidian note entering
Hands-on

Publishing Obsidian Drafts Through GitHub Actions

Best forBuilders publishing from Obsidian with GitHub Actions and minimal friction

A practical way to move from writing in Obsidian to publishing on a live site without copy-paste, manual uploads, or brittle one-off scripts.

Continue reading →
Wireframe grid of a website being built, with code and markdown files in the background
Hands-on

Building petralian.com: The Technical Reality

Best forBuilders curious how this site is wired — Obsidian, sync, and Next.js in practice

The why was clean. The how had corners. A ground-level account of building petralian.com — the masonry layout that fought back, a 404 page with a working Asteroids game, the TinaCMS newline problem nobody warns you about, and how AI wrote most of it.

Continue reading →
Editorial split of WordPress admin, Obsidian vault, and Next.js deployment pipeline.
Hands-on

Why I Rebuilt Petralian on Next.js (And Open Sourced It)

Best forDevelopers weighing a Next.js rebuild for content, SEO, and shipping speed

WordPress was slowing down the actual writing. Here's why I rebuilt petralian.com on Next.js, how Obsidian now sits at the center of my publishing workflow, and why I decided to open source the whole thing.

Continue reading →
Hero illustration for The AI Memory Problem: OpenClaw, Hermes, Karpathy, and the Approach That Actually
Hybrid

The AI Memory Problem: OpenClaw, Hermes, Karpathy, and the Approach That Actually Survives

Best forBuilders and product leads comparing durable memory approaches for agents

Every AI session starts from scratch. Four tools are racing to solve the AI memory problem - OpenClaw, Hermes, Karpathy's LLM wiki, and a plain Obsidian vault. Here's how they differ and which approach actually survives tool churn.

Continue reading →