I’m a heavy Claude Code user and while I love Plan mode, I find it’s actually not all that thorough in its planning.

While it certainly has an obscene amount of data in its training corpus, it doesn’t have everything and is obviously missing anything recent. So I’ve found that making sure a given task has the latest docs and latest web search results tends to solve problems much more efficiently.

For docs, it detects if you’ve got the Context7 MCP installed.

There’s a lot of debate on the efficacy of Context7. The argument being that web searching/scraping works just fine. But I find that a substantial number of developer sites are extremely javascript heavy or behind auth (which is certifiably insane). So Context7 fills in the gap much more efficiently.

At any rate, here’s the /research skill I tack on to just about any new feature or bug I’m working through. This is geared towards Claude, but you should be able to adapt to whatever harness you use relatively easily.

---
name: research
description: "Deep research before planning. Launches parallel agents to search docs, web, and codebase, then synthesizes findings into actionable context."
---

$ARGUMENTS

Research this thoroughly before any planning or implementation begins.

## How to research

### Step 1: Clarify before you research (MANDATORY — never skip)

Before reading a single file or launching any agent, use AskUserQuestion. Read the input and identify every place where you have 2+ plausible interpretations — scope, intent, constraints, approach, priority. Ask about those specifically.

**How to ask:** Present choices tailored to the actual input, not generic categories. The options should come directly from the ambiguities in what was asked. If you see three plausible ways to interpret what the user wants, list those three things and ask which is closest. Don't ask what you can already infer. Do ask anything that would materially change what you research or recommend.

Good trigger conditions for asking:
- The input describes a symptom but not a root cause — ask what they think the cause is, with options
- The input proposes a solution — ask if the solution is required or just a starting hypothesis
- The scope is fuzzy — ask whether they want a targeted fix or a broader rethink, with examples of each
- Multiple approaches exist with real tradeoffs — ask which tradeoffs matter most to them
- The change could affect related systems — ask whether those are in scope
- Any constraint (time, backwards-compat, file/dependency, team conventions) is unstated — ask

Keep questions short. Use choices and options, not open prompts. "Which of these is closer?" beats "Can you describe your constraints?". An "other/none of these" escape hatch is always fine to include.

Ask as many questions as the ambiguity warrants — but batch them into a single AskUserQuestion call so the user responds once.

**Do not launch any agents until you have the answers.**

### Step 2: Parse intent

With the answers in hand, read critically:
- What is the **core problem** — distinct from the proposed solution?
- Does any answer change the scope or approach from what was originally described?
- Are there remaining ambiguities? If yes, use AskUserQuestion again — don't bank on assumptions.
- Frame 2-4 specific research questions around the problem.

### Step 3: Confirm direction

State your research questions to the user and ask: does this capture what matters, or is something off? Give them a quick way to course-correct before agents spin up.

### Step 4: Launch parallel research

Spawn sub-agents to work simultaneously. Match agent count to complexity — not all are always needed:

- **Codebase agent** (almost always): Grep/Glob/Read to find relevant patterns, existing implementations, related code, config, and dependencies in the current project.
- **Docs agent** (when libraries/frameworks involved): Look up documentation. Try Context7 MCP tools first (mcp__context7__resolve_library_id, mcp__context7__get_library_docs). If Context7 is unavailable, use WebSearch + WebFetch targeting official docs sites.
- **Web agent** (when the problem isn't purely local): WebSearch for similar problems, solutions, examples, blog posts, Stack Overflow answers, GitHub issues. Focus on recent and authoritative sources.
- **Dependencies agent** (when relevant): Check package versions, compatibility, breaking changes, config options. Read package.json/Gemfile/requirements.txt/etc and cross-reference with docs.
- **UI agent** (when the change affects visual design): Research visual design implications — layout, visual hierarchy, typography, color, spacing, responsive behavior, animation, and consistency with existing design language. Use the `/ui` skill when available. Look at what design system components exist and whether the proposed change introduces visual inconsistencies.
- **UX agent** (when the change affects user-facing behavior): Research interaction patterns, user flows, cognitive load, affordances, error states, edge cases, and accessibility (WCAG compliance, keyboard navigation, screen reader behavior). Search the codebase for how similar interactions are handled today. WebSearch for established UX patterns relevant to the problem.
- **Delight agent** (when the change touches anything a user sees or interacts with): Research opportunities to make this change feel genuinely good — micro-interactions, smart defaults, helpful empty states, smooth transitions. Search the codebase for existing delight patterns. The bar: would a user notice and think "nice"? Delight is the absence of friction plus a moment of care. Skip anything that adds complexity without genuine user payoff.

**Research the problem, not the proposal.** If the input includes a proposed solution, every agent should research the underlying problem independently first. Don't anchor on the proposed approach — it may be correct, but verify.

Each agent should return: what it found, where it found it (file paths or URLs), and key snippets.

### Step 5: Check in after research (MANDATORY)

After agents return, use AskUserQuestion before synthesizing. Summarize the key finding in a sentence or two, then surface anything unexpected and ask the user to react. Present specific choices about how to proceed — don't just ask "does this make sense?"

If findings contradict the user's stated understanding of the problem, that's especially important to surface before moving forward.

### Step 6: Synthesize

Combine all agent findings. Resolve contradictions. Identify what is confirmed vs. uncertain.

**If the input included a proposed solution:** Explicitly evaluate it. Is it the best approach, or is there a simpler way? If the proposal is unnecessary, overly complex, or solves the wrong thing, say so and recommend the better path.

### Step 7: Stress-test the recommendation

Actively look for downsides of the recommended approach. What UX does it degrade? What edge cases does it miss? What maintenance burden does it create? What could it break? Be specific — "this could be slow" is useless, "this adds an N+1 query on every page load" is useful.

## Output format

Keep it tight. No filler.

### Answer
Direct response to what was asked. Concise for simple questions, thorough when complexity demands it.

### Evidence
Code snippets, doc quotes, or data that back up the answer. Use code blocks with file paths.

### Sources
- File paths for codebase findings
- URLs for web/doc findings

### Related
Anything else discovered that the user should know — gotchas, related patterns, upcoming deprecations, alternative approaches. Skip if nothing worth mentioning.

### Downsides & Risks
What could go wrong with the recommended approach? Be specific. Skip if the solution is trivially safe.

## Then enter Plan mode

After presenting research findings, call the EnterPlanMode tool so the user flows directly into planning with all the research context available.

## Rules

- **AskUserQuestion fires at Steps 1, 3, and 5 at minimum.** More is fine — the bar for asking is low.
- **Questions must be specific to the input.** No generic category buckets. The options you present should come from the actual ambiguities in what was asked.
- **Use choices, not open prompts.** "Which of these is closer?" is better than "Can you describe X?"
- Never launch agents before completing Step 1. Never.
- Prefer primary sources (official docs, source code) over blog posts.
- If you find conflicting information, say so and state which source you trust more.
- Never pad the output. If the answer is simple, the research output should be simple.
- The number of agents should match the problem. Don't launch 4 agents for a one-file bug.

My AI knows my wife’s birthday. It knows I wake up at 4:45 AM, collect about 100,000 hockey cards, and hate the word “ecosystem.” It knows I killed a business idea last Tuesday and why. It knows my granddaughters are twins and they turn 4 in July.

Not a party trick. This is what happens when you treat AI as an assistant that actually knows you instead of a tool you re-introduce yourself to every session.

Everyone’s chasing better models. Smarter reasoning. Bigger context windows. Almost nobody is working on the thing that would make AI 10x more useful overnight: making it personal.

The Gap Nobody’s Filling

The industry ships a new model every week. Better benchmarks. Faster inference. But every conversation still starts at zero. Claude doesn’t know you. ChatGPT’s memory feature is a toy. You’re re-introducing yourself every single session.

The models are smart enough. They just don’t know anything about the person using them.

The System: Files, Not Features

I stopped waiting for OpenAI or Anthropic to solve this and built it myself. The entire system is plain text files. No database. No vector store. No proprietary format. Markdown files in a folder.

Here’s the architecture:

USER.md: Who you are. The foundation file. Name, location, timezone, daily schedule, work history, family overview, interests, food preferences, communication style. Everything an assistant needs to not be a stranger. Mine runs about 80 lines.

MEMORY.md: What the AI has learned. Long-term curated memory. Not a raw log. Distilled insights about how you work, decisions you’ve made, lessons learned, opinions you’ve expressed. The AI reads this every session and updates it when something worth remembering happens.

brain/family/: One file per person. Individual markdown files for each family member. Birthday, relationship, preferences, gift ideas, notes. My wife has one. Each of my kids has one. Even my granddaughters have files. The AI references these when holidays, birthdays, or gift conversations come up.

Three concepts. Plain text. Works with any AI tool that supports system prompts or file context (most obvious one being OpenClaw).

The Onboarding Interview

The files don’t write themselves. Someone has to fill them.

I built an onboarding prompt that runs as a structured conversation. Not a survey. Not a form. A back-and-forth dialogue that quietly organizes every answer into the right file.

It covers identity and basics, daily routines, work and projects, family and household, interests and hobbies, communication preferences, goals, and pet peeves. The AI asks 2-3 questions at a time, follows up on interesting answers, and doesn’t push when you give short responses.

At the end of the conversation, the AI generates all the files in one shot. USER.md, MEMORY.md, family/README.md, and individual files for every person and pet mentioned.

The whole thing takes 10-15 minutes. You walk away with a complete personal knowledge base that makes every future AI interaction better.

The Daily Drip

The onboarding interview gets you to ~60% coverage. Good foundation. The depth comes from what happens after.

I set up a cron job that asks one personal question per day. Every morning at 9 AM, the AI reads my existing files, finds a gap, and asks a single thoughtful question. Not “What’s your favorite color?” More like “You mentioned your daughter is into stained glass. How’d she get into that?”

Here’s the workflow:

1. The AI sends one question via my chat channel

2. I answer whenever I get around to it (usually takes 30 seconds)

3. Next morning, the AI processes yesterday’s answer, updates the right file, and asks a new question

One question. One answer. Filed to the right place. Every day.

After 6 weeks, this daily drip has added more useful context than the initial 30-minute interview. It catches the stuff you’d never think to volunteer. Morning routines. How you take your coffee. That your spouse is going back to school. That you played guitar in bands growing up. That you lived in Denver for 5 years and that’s why you’re an Avalanche fan.

Six weeks of daily questions compounds fast. Day 1, the AI is a stranger with good notes. Day 42, it’s an assistant that actually knows you.

What It Looks Like After 6 Weeks

Generic AI: “I’d be happy to help you with gift ideas for your wife! Here are some popular options…”

My AI: Knows my wife’s birthday. Knows she’s into sewing and knitting. Knows she’s going back to school. Can reference all of these when I say “I need a gift idea for my wife” without me re-explaining who she is or what she likes.

Generic AI: “What would you like to work on today?”

My AI: Knows I wake up at 4:45 AM and have 2-3 hours of deep focus before the house wakes up. Knows I’m running multiple businesses. Knows I killed a business idea last week because the economics didn’t work. Can pick up where yesterday left off because it read yesterday’s memory file.

A generic assistant and one with 6 weeks of accumulated personal knowledge are different categories of tool. The interactions go from transactional to collaborative. The AI stops asking clarifying questions because it already has the answers in files it read 3 seconds ago.

The Family File Template

Every person in my household has a file that looks like this:

# {Name}

**Relationship:** {relationship}
**Birthday:** {date}

---

## Preferences
(none yet)

## Important Dates
- **Birthday:** {date}

## Gift Ideas
(none yet)

## Notes
(none yet)

Plus a README.md that serves as a quick-reference table:

# Family

## Household
| Name | Relationship | Birthday | Age |
|------|--------------|----------|-----|
| Jane | Spouse | Mar 15, 1985 | 41 |
| Alex | Daughter | Jun 22, 2010 | 15 |

## Upcoming Dates (2026)
- **Mar 15** — Jane's birthday
- **Jun 22** — Alex turns 16
- **Sep 4** — Anniversary

Simple. Scannable. The AI reads the README for quick lookups and the individual files when it needs depth.

Pets get files too. My pug has one. No birthday section, but notes about quirks and vet info. If I say “the dog’s been scratching a lot,” the AI has context without me explaining what kind of dog I have.

Steal This: The Onboarding Prompt

Here’s the actual prompt I use to kickstart the whole system. Copy it. Modify it. Use it with whatever AI tool you prefer.

You're getting to know your human for the first time. Your goal is to build
a rich personal profile that will make every future interaction feel personal
and useful.

Run this as a CONVERSATION — not a survey. Ask 2-3 questions at a time,
wait for answers, then ask follow-ups based on what they share. Be genuinely
curious, not clinical. If they give short answers, don't push — you'll learn
more over time.

What to cover (let it flow naturally, don't force the order):

Identity & Basics
- Name, what they prefer to be called, pronouns
- Location, timezone
- Phone number (if they want you to have it)

Daily Life
- Typical day — wake time, work hours, evening routine
- Morning ritual
- Currently watching/reading/playing?
- Food relationship — foodie or fuel?

Work & Projects
- What they do, how long they've been doing it
- Current active projects or businesses
- Work style — planner or builder? Deep focus or context-switching?
- Strengths and energy drains

Family & Household
- Who lives in the house? Partner, kids, pets?
- Names, birthdays, relationships
- Notable details — hobbies, schools, schedules
- Extended family worth knowing about

Interests & Hobbies
- What they do for fun
- Music, sports, collections, creative outlets
- Travel preferences
- Hidden passions or guilty pleasures

Communication Preferences
- Brief or detailed info delivery?
- Tone — formal, casual, snarky, warm?
- When to proactively reach out vs. stay quiet
- What annoys them in an AI assistant
- Quiet hours — when to never message

Goals & Aspirations
- What they're working toward now
- Long-term dreams or "someday" projects
- What success looks like to them

Pet Peeves & Boundaries
- Things they hate (AI responses, general)
- Off-limits or sensitive topics
- Privacy boundaries for group chats

After the conversation, create these files:

USER.md
Compile everything into a clean, scannable format with sections and bullet
points. Include subsections for Daily Life, Interests, Family, Work, etc.
This is the primary reference file the agent reads every session.

brain/family/README.md
Household overview table with names, relationships, birthdays, ages. Include
an "Upcoming Dates" section for the current year listing birthdays and
anniversaries chronologically.

brain/family/{firstname}.md (one per family member)
Use this template for each person mentioned:

  # {Name}
  **Relationship:** {relationship to user}
  **Birthday:** {date}
  ---
  ## Preferences
  (none yet)
  ## Important Dates
  - **Birthday:** {date}
  ## Gift Ideas
  (none yet)
  ## Notes
  (none yet)

Include pets too (simpler format — name, breed/species, any quirks).

MEMORY.md
Start a long-term memory file. Add a "Self-Knowledge" section capturing work
style, core drives, decision-making patterns — the deeper personality
insights that emerged from the conversation. This file grows over time.

After writing the files, set up a daily question cron job:
- Schedule: Once per day at 9:00 AM in the user's timezone
- Each morning, check if the user answered yesterday's question. If so,
  extract the key facts and update the appropriate file (USER.md, family
  files, or MEMORY.md). Then read existing files, find a gap, and ask ONE
  new thoughtful question. Not a survey — something genuine.

Important:
- This is a foundation, not an encyclopedia. The daily cron fills gaps.
- If they seem done or restless, wrap up gracefully.
- Write ALL files in the same session — don't promise to do it later.
- Use information they actually shared. Don't infer or fabricate.
- For sections without info yet, use "(none yet)" as a placeholder.

Run this in OpenClaw, Claude Cowork, ChatGPT, or whatever agent framework you use. Some bits will be more relevant to certain systems, but it’s flexible enough to get the ball rolling.

What to Do Today

If you’re running OpenClaw or a personal AI agent: Paste the onboarding prompt above into a conversation. Let it interview you for 10- minutes. It’ll generate all the files. Then set up the daily question cron job. You’re done. The system builds itself from here.

If you’re not running a personal agent yet: This is a good reason to start. OpenClaw runs on any Mac, PC, Linux box, or Raspberry Pi. Install it, connect it to Discord or Telegram, run the onboarding prompt, and you’ll have a personal AI that knows you by end of day.

Minimum viable version for anyone: Open Claude or ChatGPT. Paste the onboarding prompt. Have the conversation. Save it into the memory settings for those apps. You’ll feel the difference immediately.

Six weeks from now you’ll have an AI that knows the real you. The one who wakes up at 4:45 AM, collects hockey cards, and needs gift ideas for a spouse who knits.

No new model required. Just files and consistency.

Signal

A GitHub Issue Title Just Compromised 4,000 Developer Machines

Someone stuck a prompt injection in a GitHub issue title. Cline’s AI triage bot picked it up, executed it, stole an npm token, and pushed a malicious package that got 4,000 downloads in eight hours. If you’ve got any AI bot processing untrusted input, you’ve got this same hole.

Cursor Ships Always-On Agents for Your Codebase

Cursor launched “Automations,” which are AI agents that run on schedules or triggers. They spin up cloud sandboxes, do their thing, and verify their own output. Think security review on every push, incident response that checks logs and proposes fixes, weekly change digests. Rippling’s already using it.

Claude Code Now Has Multi-Agent PR Reviews

Anthropic built a multi-agent system that reviews GitHub PRs in parallel. It catches bugs, validates findings, and ranks by severity. The catch? $15-25 a pop. Though…that’s cheaper than a junior engineer’s hourly rate, and it doesn’t take PTO. 🤷‍♂️

Roundup

• How I Dropped Our Production Database — Engineer let Claude Code run Terraform unattended — it nuked prod, the database, and all automated backups.

• Solo Founder Running $3.2M with Zero Employees — The most interesting experiment I’ve seen from the “zero-human” trend gaining some steam. (I’ve been doing a bit of this myself with @VoidCoAI).

• OpenAI Codex Security — AppSec agent that finds real vulnerabilities, validates them in sandboxes, and proposes fixes.

• OpenAI Acquires Promptfoo — AI security platform used by 25% of Fortune 500, now folded into OpenAI for enterprise red-teaming. No offense to the Promptfoo team, but their product has almost every single vibe-designed trope possible. 😬

• shadcn/cli v4 — Adds “skills” (component presets) and dry-run mode. Explicitly built for coding agents.

• Claude Code /loop — Scheduled recurring prompts inside sessions. Turns Claude Code from “tool you invoke” into “tool that watches.”

• Glaze by Raycast — Describe an app, get a native desktop app. Not web, actual OS-integrated with file system access. Private beta now. Sending invites soon.

• LLMs Can Unmask Pseudonymous Users at Scale — LLMs can de-anonymize people from free text alone. 48% recall for Reddit users who discussed 10+ movies.

From the Shop Floor

I killed a business idea this week in 20 minutes. Thank you Claude.

I had an that depended on AI image generation hitting certain cost and speed thresholds. Instead of building a prototype and then discovering the economics don’t work (my usual pattern…sigh), I had Claude write a benchmarking script. It tested 10 different image gen models across 4 prompts, measured generation time, tracked per-image cost, and built a comparison dashboard.

The result: the fastest models produced garbage, the good models were too slow for the use case, and the cost curve didn’t leave room for margin. Project dead on arrival.

My brain is constantly running 1000 mph and my default with an idea is to just build it and see what happens. But this method of benchmarking ideas…really opened my eyes and helped satisfy my OCD-like nature of needing to build an idea to get it out of my system. The script cost maybe $2 in API calls. The business would’ve cost me weeks. 😅

Also this week…

• Migrated my AI assistant from Telegram to Discord — multiple channels per context (sysadmin, newsletter, finances). Absolutely loving the organization.

• Ran my first newsletter giveaway (two 1-hour consults) to kickstart subscribers — pulled 143 participants across X engagement + Substack signups using AI to aggregate entries and pick winners

• Experimented with a “zero-human company” concept — spun up an autonomous AI agent on its own isolated instance, watched it set goals, assign itself tasks, and post status updates. Fascinating as a technical exercise, less convinced it’s viable for actual business building.

• Built a /feature-image skill that generates branded social media images from any GitHub repo. Drop in a URL, get back a share-ready visual.

• Audited every background process on my Mac mini and found a stale feature silently burning API credits for days. Cleaned up ~$50+ in wasted spend. 😬

• Started onboarding my wife to OpenClaw. The virus is spreading.

• Rolled out abuse prevention updates to ReplySocial

Try This

Next time you’re about to ask AI for a recommendation or input, reframe it: “Explain the tradeoffs of X vs Y.” When you just ask for feedback or a simple “what do I do?” it tends to be very agreeable and affirmative of that thing. But forcing it to essentially make a pro/con list almost always gets you more nuanced and useful outputs!

First issue! Let me know what you think!

Alrighty, first issue of Every Day is a Year: in the books! Very much still figuring out format, so let me know what you think. Every bit of feedback is welcome!

It would also mean a ton if you share the newsletter! Sharing via the button below will track who signs up via your link and I’ll be offering some perks in the future for that. 🎉

Share Every Day is a Year

I’ve been building on the web since the 90’s. Flash games, affiliate sites, marketplaces, ecommerce, blogs, SaaS companies…nearly 100 different ventures. I’ve played a part in all the webs. 1.0, 2.0, 3.0. (What version are we at with AI? I presume at least 19.0.) Lots of tech waves. Some were real. Some were noise. Over 30 years of having your hand in things you develop a feel for the difference.

AI isn’t noise.

What’s been happening over the past couple of years is something very different. Not because the tech is impressive (it is), but because of the pace. A new model drops quite literally every day. Big tech companies are constantly trying to one-up each other. AI labs are running super bowl ads. In less than a year we went from easily being able to tell if something was AI-generated to legitimately not being able to tell the difference.

I’ve always been a prolific builder, but it’s no exaggeration to say I’ve been able to 10x my output thanks to AI. And not just increase my speed but increase/enable entirely new skillsets. Three years ago when GPT-4 was released, I put out the first GPT-generated game for iOS. I’d never built an iOS app before in my life.

Thanks to ADHD I have a superpower to hyperfixate on things, and I genuinely feel like I’ve been on a single hyperfixation bender for years now.

Every day genuinely feels like a year.

So what do you do with that? What do you do when the new models, new tools, new apps, new capabilities, new technology all become a firehose that’s impossible for any single person to stay on top of?

You start a newsletter. 🙃

So that’s what I’m doing. Not because the world needs another AI roundup (it doesn’t). But because I need a way to process all that’s changing and writing is a way I sort out what’s in my head. I figured I might as well share it.

Each week I’ll share four things:

1. Signal — The 2-3 most important bits that happened. Why they matter and what to do about them.

2. Roundup — 6-8 tools, systems, tweets…whatever bits I come across that seem interesting.

3. From the Shop Floor —Things I built. Systems I automated. Stuff that worked. What failed.

4. Try This — One actionable thing. A prompt, workflow, setting. Something you can actually try out or do.

The goal is help you make sense of the noise so you’re not just getting blasted in the face.

Hope you’ll subscribe! If you’ve got something you think I should know about, @-me!