Markdown Files.

When you work with AI tools, you'll encounter .md files constantly. Markdown is a plain text format — no fonts, no formatting buttons, no design tools. Just text with a few simple conventions: a # makes a heading, **bold** makes bold, - makes a bullet point.

That simplicity is the point.

Markdown is the preferred input and output format for almost every serious AI workflow. When you write a structured prompt, a style guide, a specification, or a plan — you're almost certainly writing Markdown, whether you realise it or not. When an AI produces something meant to be read by another AI or processed further, it usually outputs Markdown.

Why? Because it's structured enough for machines to parse reliably, but readable enough for humans without any special tools. It has no opinions about fonts or layout, so the content is all that matters.

What this means for you: Start writing in Markdown. Use it for notes, briefs, specifications, and instructions you give to AI tools. A plain text editor is all you need. The habit of writing in structured plain text is one of the highest-leverage skills you can build right now.

Tokens.

A token is roughly three to four characters of text, or about three-quarters of a word. It's the fundamental unit that AI language models use to read and generate text — the model doesn't see words, sentences, or documents. It sees a stream of tokens.

Tokens matter because they're how everything gets measured:

  • Cost: Most AI providers charge per token consumed (input) and per token generated (output). Knowing this helps you understand why a 400-word structured prompt costs more to run than a 10-word casual question.
  • Speed: Generating more tokens takes longer. Long outputs from complex reasoning models can take time.
  • Context limits: Your context window (see below) is measured in tokens.
  • Model capability: Different models have different token limits and different costs per token.

You don't need to count tokens manually. But understanding that tokens are the currency of AI interactions helps you reason about cost, speed, and limits in a way that "I sent a message" doesn't.

Context Windows and Context Management.

This might be the single most important concept for becoming an effective AI user.

Every AI session has a context window — the total amount of text (measured in tokens) that the model can "see" at once. This includes the entire conversation history, any files or documents you've provided, the system instructions behind the tool you're using, and the response being generated.

When you start a fresh session, the context is empty. As the conversation progresses, every message you send, every response the AI gives, every file you attach — all of it accumulates in the context. Once the context is full, the model starts losing access to earlier parts of the conversation.

This is why sessions go wrong. A model that seems confused, starts contradicting itself, or produces increasingly generic output is often working in an overloaded context. It's not "getting dumber" — it's working with degraded information.

Practical rules

  • Start fresh sessions for new tasks. Don't carry a morning's worth of conversation into an afternoon task.
  • Keep your context under 50% where visible. Most serious tools show you context usage. Treat 50% as a soft ceiling and consider starting fresh.
  • Be cautious with very large context windows. Some models advertise 1 million token context windows. Technically impressive, but models often lose coherence in the middle of extremely long contexts. Large ≠ better. Focused ≠ limited.
  • Front-load the important information. What you put at the beginning and end of your context is recalled more reliably than what sits in the middle.
  • Every turn is cumulative. A session of 40 exchanges has a very different context profile to a session of 5. This is why experienced users start clean sessions aggressively.

Context management is where casual users and power users diverge most visibly. The skill isn't prompting — it's knowing what to put in the room and when to clear the room.

Model Differences: Knowing Which Tool for Which Job.

Not all AI models are equal, and "the best one" is context-dependent. Most providers offer a range of models, and understanding the broad categories will save you time and money.

The main spectrum: reasoning vs. speed

Advanced reasoning models (examples: o3, Gemini 2.5 Pro, Claude Opus) are slow, expensive, and genuinely powerful. They're designed to think through complex problems step by step before responding. Use them for strategic analysis, multi-step problem solving, evaluating difficult tradeoffs, or anything where being wrong is costly.

Balanced models (examples: Claude Sonnet, GPT-4o, Gemini 2.0 Flash) sit in the middle. Fast enough for interactive work, capable enough for most professional tasks. This is where most daily work happens.

Lightweight/fast models (examples: Claude Haiku, GPT-4o mini) are cheap and quick. Ideal for simple tasks: summarising, reformatting, classifying, answering direct questions where you don't need deep reasoning.

What this means in practice

Using an advanced reasoning model to summarise a meeting transcript is like using a chainsaw to slice bread. Using a lightweight model to analyse a complex competitive strategy is the inverse. Match the model to the task.

Most providers charge significantly more for their top reasoning models — sometimes 10–20× more per token than their standard models. When you're running dozens of tasks, that adds up fast.

Pro tip: When you're unsure which model to use, ask the AI itself. Describe the task and ask it to recommend the appropriate model tier for the job. Most tools are honest about this.

Tool Usage: The Difference Between Smart and Capable.

A conversational AI with no tools is like a brilliant colleague locked in a soundproof room — they can think, but they can't do anything with the outside world. Tools are what turn a smart model into a capable agent.

When an AI has access to tools, it can take actions, not just generate text.

File access (read and write)

The ability to read files from your computer and write files back is foundational. Without it, every session starts from scratch. With it, your AI can work with real documents, save outputs persistently, and maintain state across sessions. This is the minimum baseline for serious work.

Data connections

APIs, MCP (Model Context Protocol) servers, CLI tools, and database connections allow the AI to pull in real, live data rather than relying on what you've pasted into the chat. Your CRM, your analytics platform, your project management tool — if there's an API or MCP connector, an AI agent can work with that data directly. This is where AI moves from assistant to colleague.

Browser tools

Browser automation allows the AI to navigate websites, fill forms, take screenshots, and extract information from the web. Tools like Playwright give AI agents a fully functional browser. Useful for research, scraping, testing, and workflows that involve web-based tools.

Desktop / computer use

The frontier category. Some modern tools (Claude's computer use capability, OpenAI Operator) can take control of your entire desktop — opening applications, clicking buttons, navigating interfaces, performing tasks in any software on your machine. This is early-stage but developing rapidly. The implication is significant: any software becomes scriptable if an agent can see and interact with your screen.

What to ask when evaluating any AI tool: What tools does it have access to? A tool with no file access, no data connections, and no external integrations is a conversation engine. A tool with the right integrations for your workflow is a force multiplier.

Skills: Composable, Reusable, Shareable Capabilities.

Skills are one of the most important structural developments in AI tooling, and most non-engineers have no idea they exist.

In December 2025, Anthropic published the Agent Skills specification as an open standard at agentskills.io. Within months, it was adopted by OpenAI (ChatGPT and Codex CLI), GitHub Copilot, Google Gemini CLI, Cursor, JetBrains Junie, and dozens of other platforms. It has become the industry standard for packaging reusable AI capabilities.

What a skill is

A skill is a plain text Markdown file — typically named SKILL.md — that gives an AI agent a set of reusable instructions for a specific task. It can include a description of what the skill does, step-by-step instructions, references to supporting assets, and metadata that controls when and how the skill activates.

When you invoke a skill — usually by typing a /skill-name command in a supported tool — the agent loads that file and uses it as its instruction set for the task. The skill author has already done the thinking about how to approach the task well. You provide the specific inputs.

Why this matters for non-engineers

Skills can be written by anyone who can write clearly. You don't need to code. A domain expert — a journalist, a marketing director, a finance analyst, an HR manager — can write a skill that encodes their expertise into a reusable workflow. Once written, that skill can be shared with a team, version-controlled, and improved over time.

Skills are how organisations move from "individual AI use" to "systematic AI capability." A brand skill. A reporting skill. A contract review skill. A briefing skill. These are not theoretical — they're being built and used today.

The composability point

What makes skills powerful at scale is composability. One skill can call another. An agent can select from multiple skills depending on the task. Skills can be combined into workflows. The intelligence isn't in any single prompt — it's in the architecture of skills working together, each drawing on your organisation's domain knowledge.

Where to go deeper:

Planning Before Doing: Research → Plan → Implement.

One of the most common mistakes new AI users make is diving straight into execution. They open a tool, describe a task, and expect a finished result. Sometimes that works. Often it doesn't — especially for anything non-trivial.

The tools themselves have converged on a recognition of this. Claude Code has a dedicated plan mode. OpenAI Codex separates planning from implementation. Most serious agentic frameworks enforce a structured sequence before any action is taken. This isn't coincidence — it's hard-won wisdom about how AI agents produce reliable, high-quality output.

The Research → Plan → Implement pattern

The most robust framework is a three-phase approach:

1. Research — before anything else, gather context. What already exists? What are the constraints? What does success look like? This phase is collaborative: you and the AI exploring the problem space together, not building anything yet. The output is shared understanding.

2. Plan — based on research, produce a concrete plan. In a planning session, you agree on approach, sequence, decisions, and success criteria. The output is a document — a specification, a brief, a structured plan — that can stand alone without the conversation context.

3. Implement — critically, this often happens in a new session with the plan as input. Fresh context, clear instructions, no accumulated noise from the research and planning conversation. The implementation agent doesn't need to know how you got to the plan — it just needs the plan.

Similar frameworks have converged on the same insight under different names:

  • RPI (Research → Plan → Implement) — developed and battle-tested by HumanLayer, the canonical framework for agentic coding.
  • GSD (Get Shit Done) — a meta-prompting and spec-driven development system for Claude Code with 48,000+ GitHub stars. Solves "context rot" by orchestrating ephemeral sub-agents each with fresh, isolated context. gsd.build
  • GStack — Garry Tan's 23-role, 7-phase workflow (Think → Plan → Build → Review → Test → Ship → Reflect) with role-based specialists and explicit gates between phases.

Why a new session for implementation?

This is counterintuitive until you've experienced it. A long research and planning conversation accumulates context: wrong turns, discarded ideas, interim outputs, exploratory thinking. Feeding all of that into an implementation agent creates noise. A clean session with a clean plan produces dramatically better results.

The plan document is the bridge between sessions. Write it so it's self-contained: what to build, how to build it, what constraints apply, what success looks like. An agent reading only that document should be able to execute without asking clarifying questions.

What this means day-to-day

Don't ask AI to produce finished outputs from vague briefs. Instead: start with a research conversation, agree on a plan, write the plan down, start fresh, implement. The discipline of this workflow separates people who get consistent value from AI from people who get occasional lucky outputs.

Meta-Prompts and Composable Scaffolding.

There is a persistent myth that the key to getting great results from AI is writing the perfect prompt. This has led to a small industry of "prompt engineers" selling collections of "magic prompts" that supposedly unlock superior performance.

This framing is mostly wrong, and it's increasingly irrelevant.

What actually drives quality

The quality of an AI output is primarily a function of three things:

  1. The model's capability — what it can do
  2. The context it's given — what it knows about the task
  3. The scaffolding around your input — how the system structures, enhances, and routes your request

The third factor is where the real leverage lives, and it's mostly invisible to the user. When you invoke a skill, use a specialised tool, or work within a well-configured agentic harness, there is sophisticated scaffolding running around your simple input. System prompts that establish role and behaviour. Context injection that pulls in relevant information. Routing logic that selects the right model and tools for the task. Structured output constraints that keep results consistent.

This scaffolding is written by the skill or tool author. Your job isn't to write the perfect prompt — it's to provide the best possible substance: your domain expertise, your specific requirements, your context.

Meta-prompts specifically

A meta-prompt is a prompt that wraps around your input to enhance it. Rather than "here is my request," a meta-prompt might say: "You are [role]. The user will provide [input type]. Your job is to [process it this way], considering [constraints], and output [format]. Here is the user's input: [your input]."

Skills are almost always meta-prompts at their core. The skill author has written the wrapper — the role, the workflow, the output structure. You provide the substance. The quality comes from the combination.

What this means for building skills and workflows: The highest-leverage thing you can write is not a standalone prompt — it's a reusable wrapper that elevates whatever input gets fed into it. Think about the workflow, not the words.

This article is a companion to the Vibe Coding for Everyone workshop from Ringier Future Summit 2026. More resources at futuresummit.dylanharbour.com.