The Neuron's AI Skill of the Day Digest (March 2026)

Here's the thing about AI skills in 2026: they're not really about prompts anymore.

Sure, a well-crafted prompt still matters. But the gap between "person who uses AI" and "person who's genuinely faster because of AI" has shifted. It's less about what you type into the chat box and more about how you set up the systems around it: agents that run while you sleep, plugins that extend what your tools can do, workflows that chain multiple AI steps together without you babysitting each one.

That's why we renamed this section. "Prompt Tip of the Day" served us well for over a year, but the skills that matter now are bigger than a single prompt. They're agentic workflows, automation recipes, tool configurations, and thinking frameworks that compound over time.

This March collection captures the best of what we've found, tested, and shared with 675K+ readers. Some tips are still classic prompt techniques (the good ones never go out of style). Others are full workflows you can set up once and benefit from forever.

Every skill comes with concrete steps, links, and copy-paste examples. Bookmark this page. We'll update this page on a bi-weekly basis when we publish new tips. Come back when you need it.

AI Skills from the Week of March 3

March 10

Make Your Codebase Agent-Ready: The 7-Point Agent Legibility Checklist

Your codebase probably isn't ready for AI agents. Not because the AI isn't good enough, but because most repos are missing the scaffolding agents need to do reliable work.

At OpenAI's latest Build Hour, the team demoed an "Agent Legibility Score" app that grades GitHub repos on how well AI coding agents can operate in them. They scored their own open-source Symfony repo and got a B. Even OpenAI has room to improve.

The framework is based on seven metrics that Ryan Lopopolo's team developed over five months of building a million-line product with zero manually-written code. Here's each metric and how to apply it:

1. Bootstrap Self-Sufficiency

Can an agent clone the repo and get a working development environment without any external knowledge? If setup requires reading a wiki page, asking someone on Slack, or running undocumented commands, the agent will fail at step one.

What to do: Create a bootstrap.sh or Makefile that handles all setup. Document every dependency. Test it from a clean machine.

2. Task Entry Points

Are there clear, standardized commands for the core workflows (build, test, lint, run)? Agents need predictable entry points to know what to execute.

What to do: Add make build, make test, make lint, make run commands, or their equivalents. Document them in a CONTRIBUTING.md or your AGENTS.md.

3. Validation Harness

Can the agent verify that its changes actually work? As Ryan put it: "Hard to know if you completed the job if you can't measure that the job is done."

What to do: Maintain a test suite that runs quickly and covers critical paths. Add integration tests for key user flows. Make test output clear and parseable.

4. Linting and Formatting

This is the single biggest quick win. Linters let agents cheaply check their own output on every iteration. Ryan's advice: "It's super easy to add leverage to your codebase by vibing up some new lints." Use your coding agent to create custom lint rules that encode your team's preferences.

What to do: Set up a linter (ESLint, Ruff, etc.) with auto-fix enabled. Add custom rules for patterns your team cares about. Make formatting automatic on save and in CI.

5. Codebase Map

Is there a high-level map of the architecture? Agents need to know where things live before they can make effective changes.

What to do: Create an ARCHITECTURE.md that describes the main domains, package structure, and dependency directions. Keep it under 200 lines and treat it as a living document.

6. Structured Documentation

The key insight from harness engineering: AGENTS.md should be a table of contents, not an encyclopedia. A giant instruction file crowds out the actual task. Instead, use a short root file (~100 lines) with pointers to deeper docs in a structured docs/ directory.

What to do: Create a root AGENTS.md with 5-10 pointers to relevant docs. Put detailed standards (security, reliability, frontend patterns) in dedicated files under docs/. This enables "progressive disclosure" for agents; they start with a small entry point and drill deeper as needed.

7. Decision Records

Are architectural decisions logged in the repo? When agents (or new engineers) encounter a pattern, they need to understand why it's that way.

What to do: Start an Architecture Decision Records (ADR) practice. Even lightweight notes like "we chose library X over Y because Z" in a docs/decisions/ folder save agents from making the same mistake twice.

The Quick-Start Prompt

Here's a prompt to run against your own repo:

Prompt: "Analyze this repository and score it on these seven agent-legibility metrics: (1) Bootstrap self-sufficiency, (2) Task entry points, (3) Validation harness, (4) Linting and formatting, (5) Codebase map, (6) Doc structure, (7) Decision records. For each metric, give a letter grade A-F with a one-sentence explanation. Then give the top 3 highest-impact improvements I should make, with specific files to create and example content."

Beyond the Checklist: Patterns That Compound

The Agent Legibility Score is your starting point, but the harness engineering blog goes deeper. A few patterns worth stealing:

• Custom lints as taste enforcement. If you don't like a pattern the agent produces, write a lint that bans it. One OpenAI team bans duplicate utility functions across the codebase with a custom ESLint rule, ensuring agents always use the canonical, instrumented version.
• Agent-written agent reviewers. Have your coding agent create a code-reviewer agent (a specialized sub-agent) that checks PRs against your standards. Basis does this with a dedicated standards-enforcer sub-agent.
• Reflect Slack decisions into the repo. That architectural decision from a Slack thread? Tag your agent in the thread and have it add guardrails to the codebase automatically.

The underlying principle is straightforward: if an agent can't see it, it doesn't exist. Move your standards, decisions, and institutional knowledge from people's heads and chat threads into the repo, where agents can use them.

Our favorite insight: each engineer who encodes their expertise into the repo makes every other engineer's agents better. It's a compounding flywheel that didn't exist when humans were the only ones reading the docs.

March 9

Copilot Cowork is the new "agentic" layer in Microsoft 365 that moves beyond chatting with Copilot to actually delegating work. Instead of asking Copilot a question and getting a response, you describe an outcome and Cowork builds a plan, executes across your apps, and checks in at clear milestones for approval.

Here are four things you can delegate to Cowork right now (if you're in the Frontier program):

• Calendar triage: Cowork reviews your Outlook schedule, flags conflicts and low-value meetings, proposes changes, and executes them once you approve.
• Meeting prep: It pulls together a briefing doc, supporting analysis, client deck, and pre-read email from your emails, files, and past meetings.
• Customer follow-up: After a trip or event, it compiles notes across emails and meetings, drafts a summary, and sends personalized follow-ups.
• Product launch planning: It builds a competitive comparison in Excel, drafts a value proposition doc, generates a pitch deck, and outlines milestones.

The key difference from regular Copilot: Cowork runs in the background across multiple apps at once, powered by what Microsoft calls "Work IQ" (its understanding of your emails, meetings, files, and work relationships). You stay in control with approval checkpoints.

Try this prompt (once you have access):

Prepare for my meeting with [client name] on [date]. Pull together a briefing doc from our last three email threads, create a one-page summary of their account status from my Excel files, and draft a short agenda. Send me a checkpoint before you email anything.

Cowork is in research preview now and rolling out to the Frontier program in late March. The new $99/month E7 tier includes it, along with the new Agent 365 platform for managing AI agents across your org.

Favorite insight: Cowork uses the same agentic engine as Anthropic's Claude Cowork, but wired into your entire Microsoft 365 data graph. Think of it as Claude Cowork with a corporate badge and access to everyone's calendars. For a deeper look at how Microsoft is locking down agent security, check out our explainer on Agent 365.

March 8

How to Make AI an Expert on YOUR Stuff

You've probably wished you could "train" AI on your own documents, your company's data, your research... so it stops giving generic answers and starts giving your answers.

Everyone wants AI that knows their stuff. Not generic answers from the internet, but responses grounded in your company's data, your research, your specific domain.

The good news: you don't need a machine learning degree or a six-figure budget. Three tools already do this, and they're all free (or included in plans you likely already pay for). The trick is knowing which one fits your situation.

• Claude / ChatGPT Projects (best for ongoing work): Create a Project in Claude, upload your documents (manuals, SOPs, past reports, style guides), and add custom instructions. Every conversation inside that Project draws on your files automatically. This is ideal for work you do repeatedly, like writing in a specific voice or answering questions about your company's processes.
• Custom GPTs / Gems in Gemini (best for sharing with others): Build a Custom GPT in ChatGPT, upload reference files, and write instructions. Then share the link with your team or clients. They get a purpose-built AI assistant without needing to understand the setup.
• NotebookLM / CLI Tool + MD Files (best for research and learning): Upload papers, PDFs, meeting transcripts, or course materials. NotebookLM creates an AI that only answers from your sources (dramatically reducing hallucinations) and can generate audio overviews, FAQs, and study guides. Great for students, researchers, or anyone digesting dense material. You can also do this with Claude Code / Cowork or ChatGPT Codex using MD files. This is a bit more complicated though, so we'll cover this in another Skill.

The easiest version? Projects. NotebookLM is useful if you need MASSIVE context; otherwise, a dedicated project folder in the tool you use every day is probably the easiest and most fluid workflow (this is what we do, though we're in the process of converting some of this functionality over to Skills. More on that in another Skill of the Day update too).

Try this prompt in a new Claude Project after uploading your documents:

You are an expert assistant for [your company/field]. When answering questions, always reference the uploaded documents first. If the answer isn't in the documents, say so clearly rather than guessing. Match the tone and terminology used in the documents. When citing specific information, mention which document it came from.

So depending on your use-case, you probably don't need to fine-tune a model. These free tools let you upload your documents and get an AI that actually knows your business.

Now, let's dive into each of those a bit more in depth, shall we?

Claude / ChatGPT Projects: Your Always-On Work Assistant

Best for: Ongoing work where you need AI to consistently reference your materials.

Claude Projects let you create a dedicated workspace with uploaded documents and custom instructions. Every conversation inside the Project automatically has access to those files. Think of it like giving Claude a permanent briefing folder.

How to set it up:

1. Open claude.ai and click "Projects" in the sidebar
2. Create a new Project and give it a descriptive name (e.g. "Q2 Marketing Strategy" or "Client Onboarding")
3. Upload your documents: PDFs, text files, spreadsheets, code files, whatever Claude needs to reference
4. Add custom instructions that tell Claude how to behave in this context

The same process works inside ChatGPT Projects; just select Projects from the sidebar, name your project, and inside the project, click "Project Settings" to edit your instructions.

When to use it:

• Writing content in a specific brand voice (upload your style guide)
• Answering questions about internal processes (upload SOPs and playbooks)
• Analyzing data against historical context (upload past reports)
• Any repeated workflow where you'd otherwise paste the same context every time

Pro tip: Your custom instructions are the secret weapon. Don't just upload files and hope Claude reads them. Tell it exactly how to use them. For example: "When I ask about pricing, always check the uploaded rate card first. When writing emails, match the tone in the uploaded brand guide. If I ask something that isn't covered in the documents, tell me explicitly."

Gems / Custom GPTs: AI Assistants You Can Share

Best for: Building a tool that other people (teammates, clients, students) can use without setup.

Custom GPTs in ChatGPT (or Gems in Gemini) let you create a purpose-built assistant with uploaded knowledge, specific instructions, and a shareable link. The person using it doesn't need to know anything about AI. They just open the link and start chatting.

How to set up GPTs:

1. Go to chatgpt.com/create
2. Describe what you want the GPT to do in plain English
3. Upload reference files (product docs, FAQs, training materials)
4. Configure the instructions and test it
5. Publish and share the link

When to use it:

• Customer-facing FAQ bots (upload your help docs)
• Team onboarding assistants (upload your company handbook)
• Teaching tools (upload course materials and rubrics)
• Any situation where you want to give someone else a smart, specialized chatbot

The process is the same with Gemini Gems, just go to https://gemini.google.com/gems/view and click New Gem (or go straight to https://gemini.google.com/gems/create). You also have the option to set default tools if you want to do a specific action on those tools.

NotebookLM: The Research and Learning Tool

Best for: Deep-diving into specific documents with minimal hallucination risk.

Google's NotebookLM takes a fundamentally different approach. Instead of a general AI that also looks at your documents, it's an AI that only knows your documents. Upload papers, transcripts, articles, or notes, and every answer is grounded in (and cited from) your sources.

How to set it up:

1. Go to notebooklm.google.com
2. Create a new notebook
3. Upload your sources (up to 50 per notebook): PDFs, Google Docs, URLs, YouTube videos, audio files
4. Start asking questions; every response includes citations back to specific sources

When to use it:

• Studying for exams or certifications (upload textbooks and lecture notes)
• Preparing for meetings (upload agendas, past notes, and relevant docs)
• Research synthesis (upload multiple papers and ask for comparisons)
• The "Audio Overview" feature generates a podcast-style discussion of your documents, which is great for passive learning

The key difference: NotebookLM won't make things up because it literally can't answer from outside your sources. The tradeoff is that it won't help you with anything not in your uploaded materials. That constraint is a feature, not a bug, when accuracy matters.

We also mentioned that you can do this with local folders with a tool like Claude Code / Cowork, Codex, or Gemini CLI (their version of Claude Code). We'll cover that at another time.

Which One Should You Use?

Situation/ Best Tool

• I do the same kind of work every day and want AI to know my context
• • Projects
• I want to build something for my team or clients to use
• • Gems / Custom GPTs
• I need to deeply understand specific documents without hallucinations
• • NotebookLM
• I want to learn a new topic from primary sources
• • NotebookLM
• I need a writing assistant that matches my brand voice
• • Projects

You can also combine them. Use NotebookLM to deeply understand a set of research papers, then use Claude Projects with your synthesized notes to write about them in your voice.

The Prompt That Ties It All Together

Whichever tool you pick, this prompt structure works for setting up custom instructions:

You are an expert assistant for [your company/field/topic].

KNOWLEDGE: Always reference the uploaded documents first. If the answer isn't in the documents, say so clearly rather than guessing.

TONE: Match the tone and terminology used in the documents. [Add specifics: formal/casual, technical level, etc.]

CITATIONS: When citing specific information, mention which document it came from.

BOUNDARIES: [What should the AI NOT do? e.g. "Don't give legal advice" or "Don't speculate about competitors"]

The people who get the most from AI aren't the ones with the fanciest prompts. They're the ones who take 10 minutes to set up their tools with the right context. This is the simplest version of that 10 minutes. Don't put this off!

March 6

Get AI to Show Its Work (Then Fix It Before It Starts)

One of GPT-5.4's best new features is "steerable thinking plans," and the technique works across any reasoning model (Claude, Gemini, etc.). Instead of letting AI jump straight to an answer, you ask it to outline its approach first, then you correct course before it does the work.

Here's the move: after giving your prompt, add this line:

"Before you begin, outline your step-by-step plan for completing this task. Wait for my approval or edits before proceeding."

This works especially well for complex tasks like analyzing data, writing reports, or debugging code. You catch wrong assumptions early instead of getting 2,000 words of beautifully wrong output.

Our favorite insight: Like good management 101, the biggest time-saver now is catching mistakes before they happen. Think of it like reviewing a blueprint before construction, not after.

March 5

Use AI to audit your own AI strategy

Ethan Mollick recently pointed out something wild: companies in the same industry, with the same risks, are living in completely different AI realities. One has been using enterprise ChatGPT, Claude, and Gemini for 18 months. The one next door has a committee that individually approves every use case and still worries about training data leakage.

The deciding factor? Whether a senior leader is willing to assume risk. If the answer is no, IT and legal have every incentive to block everything.

Here's a prompt to pressure-test where your organization actually stands:

You are an AI adoption auditor. I work at a [company type] with [X employees]. Our current AI policy is: [paste policy or describe it]. Our competitors in this industry are using [tools you've heard about].

Please:

> Identify which of our current restrictions are based on outdated assumptions vs. legitimate risks

>List 3 peer companies in regulated industries (finance, healthcare, legal) that have deployed enterprise AI without incident (use web search to look up the most recent announcements and the most credible companies possible)

> Draft a one-page memo I can send to leadership that separates real risks from FUD, with specific mitigations for each real risk

> Include a "cost of inaction" section estimating what we lose per month by not deploying

The point isn't to railroad your legal team. It's to give leadership the information they need to make an actual decision instead of defaulting to "no."

March 4

The team at Every just published the best beginner's guide to OpenClaw, the open-source AI assistant that blew up in January (100K+ GitHub stars in a week). Unlike ChatGPT or Claude, your "Claw" lives in WhatsApp or Telegram, runs 24/7, and can change itself by writing code when it needs new abilities.

The guide walks you through three levels:

• Beginner: Set up a to-do list and daily check-ins.
• Intermediate: Connect email and calendar, get one morning briefing with everything you need.
• Advanced: Give it ongoing projects, let it make phone calls, build compound workflows.

Here’s a quick overview of what you’ll learn:

The three ways to get started…

• Laptop install: One terminal command (curl -fsSL https://docs.openclaw.ai/install.sh | bash) where it walks you through connecting to your messaging app. Takes ~10 minutes.
• Server deploy: Want to run it 24/7? Deploy on Fly.io, Hetzner, or Google Cloud so it works even when your laptop's closed.
• Hosted version: Every is building a one-click hosted option for their subscribers (request early access here).

Then it walks you through the rest of the setup:

• First task: Text your Claw: "Manage my to-do list. Every morning, send me my to-dos for the day."
• Connect tools: Text: "I want you to read my email. What do I need to do?" It handles the setup itself. Same for calendar, Notion, etc.
• Morning briefing: Text: "Every day at 8 a.m., check my email, calendar, and weather, then send me one message with everything I need."
• Go proactive: Text: "When I get a meeting invite, check for conflicts and tell me." It scans every 30 minutes and only pings you when something needs attention.

The guide is long, but something Every does that WE LOVE = if you want the shortcut, Every built a one-click “Read with Claude” and “Read with ChatGPT” button right at the top of the article, so you can chat with the whole thing and ask your own questions.

Read the full guide here. And if you want to get inspired by what you can do with this once it’s set up, watch this. 

March 3

We were inspired by today’s Claude outages to write a piece on Openrouter. Openrouter is basically a single source where you can easily switch between multiple models and model cloud providers. This is helpful for when new models come out and you want to easily switch to try it out without totally remaking your whole workflow.

You can chat with various models on their website, or use it as a gateway for your API calls. If you don’t know, an API is how two software programs talk to each other; in this case, how you use AI inside other tools.

Think of it like a universal remote for AI models. Instead of five remotes for five streaming services, you get one that controls everything, plus a private key to authenticate your access, kind of like a password, for security.

The setup to use OpenRouter anywhere takes five minutes:

• Create an account at openrouter.ai
• Add credits (prepaid; they deduct as you go)
• Generate an API key (or bring your own; more on that in the full article).
• Change two lines of code if you already use the OpenAI SDK: swap the base_url to https://openrouter.ai/api/v1 and use your OpenRouter key

Read the full version here.

March 2

Greg Isenberg stress-tested Perplexity Computer live and turned it into a one-person sales, research, and strategy team. The highlights:

• Cold outreach: It found real email addresses, researched each prospect's recent activity, wrote personalized pitches, and sent them via connected Gmail—all in parallel.
• Competitive intel: A recurring 8 AM monitor across five competitors. New episodes, pricing changes, social buzz. Nothing changed? No notification.
• VC research: Described his startup, told it to find 50 best-fit investors. Got a spreadsheet with fund sizes, partner contacts, and thesis alignment.
• Investment memos: Asked for a full Shopify analysis with charts, comparisons, and bull / bear cases. Got a PDF.

Our favorite insight: When Greg asked, "Is there something I'm not asking you that could make me more money?"—it suggested tracking competitors' new sponsors so he could reach out while their podcast budget was still hot. Try that prompt in your next AI session.