Personas: long-lived AI advisors for Claude Code — Building Products [Mischa Sigtermans](https://mischa.sigtermans.me) [ Thoughts ](https://mischa.sigtermans.me/thoughts) [ Books ](https://mischa.sigtermans.me/books) [ About ](https://mischa.sigtermans.me/about) [← Thoughts](https://mischa.sigtermans.me/thoughts) May 9, 2026 · AI Open Source Taylor is still immortal, but now he remembers ============================================== Long-lived AI advisors for Claude Code. Ask *personas* like Taylor Otwell or Steve Jobs what they think, with project-scoped memory and threads that persist across sessions. I asked Taylor to review a controller this morning. Before he gave me his take, he referred back to a decision we'd settled in an earlier review on a different file in the same codebase. He remembered. That's new. Taylor used to start every session from zero. So did Raymond, David, and Steve. I shipped the [Personas Plugin for Claude Code](https://github.com/mischasigtermans/claude-personas) today. It gives all four advisors project-scoped threads and durable memory. Same opinions as before. They don't forget anymore. The four immortal advisors -------------------------- When I shipped [Taylor Says](/thought/taylor-otwell-is-immortal-and-costs-200-month) in January, the idea was to import a developer's documented opinions wholesale. Taylor Otwell has fourteen years of Laravel writing, talks, podcasts, and merged PRs. Enough material to reconstruct how he'd review a piece of code. The pattern was good enough that I extended it. I needed reviews for other languages, and a separate voice for product work. Three more advisors followed, each for a different kind of review: - **Raymond Hettinger** for my Python code reviews. Decades of conference talks and the kind of review that turns a fifty-line for-loop into a one-line generator expression. - **David Tolnay** for my Rust code reviews. The author of serde, anyhow, syn. The clearest documented opinions in Rust on type design and error handling. - **Steve Jobs** for product and design reviews. Keynotes, interviews, Walter Isaacson's biography, Ken Kocienda's *Creative Selection*. Documented decision frameworks. Not the deification, the actual operating principles. Each one shipped as its own Claude Code plugin: taylor-says, raymond-says, david-says, steve-says. Each one stateless. One prompt, one answer, no continuity. The problem with stateless advisors ----------------------------------- Every conversation started from zero. I'd ask Taylor to review a Stagent controller. He'd give great feedback. I'd ship the change. Next time I called him on a different file in the same codebase, he had no idea we'd talked. No memory of the conventions we'd settled on. No memory of last week's decision. If I wanted Taylor to bring context, I had to bring it for him. Re-paste the CLAUDE.md notes. Re-explain that this project is a booking platform for the music industry. Re-say that I don't want service classes wrapping single Eloquent calls. That works the first time. By the tenth time, I was spending more energy briefing the advisor than reading the review. The other three had the same problem. Raymond didn't know which of my Python projects was a CLI and which was a Django app. David didn't remember which crates already had logging set up. Steve didn't remember which product direction I'd ruled out the previous quarter. A stateless advisor is a parlor trick. You learn something each time, and you re-pay the setup cost on every call. Threads and memory ------------------ Personas changes two things. A **thread** is the live transcript of a conversation with one persona. While it's open, every turn replays in the persona's context. Ask Taylor about three controllers in a row and he sees all three. He spots the pattern across them. A **memory** is what the thread distills into when it closes. Three to eight bullet takeaways: facts about the project, decisions you took, opinions the persona expressed that you accepted. The next time you talk to that persona on this project, the memory loads as preamble. Both are project-scoped. Project identity is keyed off the git remote URL, so worktrees and clones share state. Same Steve, different head per project. Steve in Stagent remembers the booking-platform launch plan. Steve in a Rust side project remembers the API decisions there. They don't bleed. Closing a thread is silent. The `personas` skill watches for 'thanks', 'got it', topic shifts, or three idle turns and closes the thread on its own. Takeaways write to memory. The transcript archives. You get a one-line note: 'Closed taylor-otwell thread. /personas reopen taylor-otwell to restore'. That's it. Four plugins retired, one plugin with memory -------------------------------------------- The standalone repos are gone. taylor-says, raymond-says, david-says, steve-says all bundle into Personas. The original `*-says` plugins are retired. Bundled personas ship disabled by default. You opt in: ``` /personas enable taylor-otwell /personas enable raymond-hettinger /personas enable david-tolnay /personas enable steve-jobs ``` Then ask in plain English: > what would taylor say about this controller? ask raymond if this generator is too clever david, is this lifetime annotation doing real work? is this spec ready for steve? The `personas` skill picks up the alias and routes the call. Same as the standalone plugins, but the persona arrives with state. Author your own --------------- A persona is a directory with one required file. `persona.md` has YAML frontmatter (name, aliases, description, traits, tools) and a system prompt. Optionally a `context/` folder for inlined voice notes and a `knowledge/` folder for deep topical guidance loaded on demand. Publish it as a git repo, then anyone can install with `/personas add https://github.com/you/your-persona`. No Claude plugin scaffolding required. That's the simple path. The four bundled ones take a longer one. A persona isn't a prompt ------------------------ The Taylor in Personas isn't a one-line system prompt that says 'you are Taylor Otwell'. It's a synthesized voice grounded in years of his actual writing, talks, podcasts, and merged PRs, layered on top of decision frameworks pulled from primary sources. I built a tool that runs this for me. It's called Quorum, it's closed-source for now, and every persona goes through a ten-step pipeline: 1. **Domain brief.** Define what the persona is for. 2. **Domain map.** Sketch the field, the sub-fields, the schools of thought. 3. **Expert discovery.** Find eight to twelve real humans who've published enough to study. 4. **Approval gate.** I prune the expert list before any deep research starts. 5. **Per-expert research.** Each expert profiled in parallel across every platform they show up on: writing, talks, podcasts, code, interviews. 6. **Pattern extraction.** Where do these experts agree? Where do they disagree, and why? 7. **Stress test.** Critic lenses pick the research apart for gaps, contradictions, and wishful thinking. 8. **Approval gate.** I review the research before anything gets built. 9. **Persona synthesis.** Voice, decision frameworks, anti-patterns. All sourced from the research, none invented. 10. **Benchmark.** Eighteen instances run the same prompt. The verdicts have to converge, or the persona goes back to the research step. The output of step 10 is what ships into Personas. The four bundled advisors all came through this pipeline. So have a few I haven't published yet. Probably a DHH for Rails next, possibly a Pieter Levels for solo-shipper energy. The pipeline is the moat. Anyone can write a system prompt that says 'you are Taylor Otwell'. Few will spend the time researching, benchmarking, and rejecting the versions that sound like an AI doing an impression. How this differs from Parley ---------------------------- [Parley](/thought/how-i-made-my-claude-code-projects-call-each-other), the other Claude Code plugin I shipped this week, is a cross-session bridge. Same Claude, different process. Parley lets you reach into another project's session and ask its agent for input from inside that project's loaded context. Personas is in-session. Same Claude process. The persona is a subagent with its own loaded context, voice, and memory state. Parley is for 'ask the project that knows'. Personas are for 'ask the advisor whose opinions I want imported'. I run them side by side. Taylor still costs $200/month. Now he remembers. ------------------------------------------------ When I shipped Taylor Says four months ago, the pitch was that you could have Taylor Otwell review every piece of Laravel code you write. Stateless, but immortal. Now he's not stateless. The Taylor in my Stagent project knows what we've decided on Stripe webhooks and what Java patterns I keep absorbing from Stack Overflow. He brings that context to every new file. So does Raymond in my Python projects. So does David in my Rust ones. So does Steve in the product reviews. Taylor's still immortal. He still costs $200/month. Now he remembers our last conversation. *thanks for reading* Hi, I'm [Mischa](https://mischa.sigtermans.me/about). I've been *shipping products* and *building ventures* for over a decade. First exit at 25, second at 30. Now Partner & CPO at [Ryde Ventures](https://ryde.ventures), an AI venture studio in Amsterdam. Currently shipping [Stagent](https://stagent.com) and [Onoma](https://askonoma.com). Based in Hong Kong. I [write](https://mischa.sigtermans.me/thoughts) about what I learn along the way. [More about me](https://mischa.sigtermans.me/about). Keep reading: [How I set up my Claude Code status line](https://mischa.sigtermans.me/thought/how-i-set-up-my-claude-code-status-line). [← Thoughts](https://mischa.sigtermans.me/thoughts) Connect ------- [X](https://x.com/mischamartijn) [LinkedIn](https://linkedin.com/in/mischasigtermans) [GitHub](https://github.com/mischasigtermans) © 2026 · [RSS](feed:https://mischa.sigtermans.me/feed)