Skip to main content
This tutorial shows how to use Skills to explain code, investigate changes, search history, and hand work off between agents.
Skills are most useful once Entire has recorded session context and checkpoints. This tutorial creates that history as you go, so you can try the Skills even if you are starting fresh.
By the end, you will:
  1. Understand what each Skill does
  2. Install the Skills locally
  3. Practice the exact prompts and commands to use
  4. Build a tiny app so the Skills have real code to work against

​
Skills

Best for cross-agent handoffs, moving work to another agent, and summarizing recent session context.Example prompts:
Why it helps: saves time, prevents duplicate work, and preserves context.
Best for understanding why a function, file, or change exists.Example prompts:
Why it helps: great for onboarding, reveals intent, and separates design decisions from accidental complexity.
Best for investigating a specific block of code or recent change.Example prompts:
Why it helps: useful in review, helps debug regressions, and gives targeted provenance.
Best for finding prior work, earlier prompts, checkpoints, or similar implementations.Example prompts:
Why it helps: helps reuse prior work, surfaces decisions, and turns old history into something searchable.

​
Prerequisites

Before using these Skills, make sure you have:
  1. Git installed
  2. A supported AI agent: Claude Code, Codex, Copilot CLI, Cursor, Factory, Gemini CLI, OpenCode, or Pi
  3. The Entire CLI installed
This tutorial uses Codex for the examples. You can use these Skills with your preferred agent, including Claude Code, Gemini CLI, OpenCode, Cursor, Copilot CLI, Factory, or Pi.

​
Install Skills

Choose the setup path that matches your tool:
See the Codex integration guide.
See the Agent Skills homepage.
See the Claude Code integration guide.
See the Gemini CLI integration guide.

​
Install Entire

Install Entire by following the main CLI installation guide.

​
Create a Project

We are going to build a tiny app called bug-notes. This project is enough to:
  • generate history
  • make changes worth explaining
  • create checkpoints worth searching
Create the project:
Run it:

​
Enable Entire

From inside bug-notes, run entire enable for Codex and sign in:
When run in a fresh project folder, entire enable -y initializes Git, creates the initial commit, creates a GitHub repo, and pushes it so checkpoints can be indexed.
If you are using a different agent, use the corresponding integration flow instead. See Codex, Claude Code, or Gemini CLI.
At this point, your project is ready to record session context and checkpoints.

​
Build the App

Open the repo in your AI agent and give it a focused task. Suggested prompt:
Once the agent finishes, commit the result:
That commit is important because the Skills become much more useful once there is committed and pushed history plus Entire checkpoint data.

​
Add History

The search skill is most valuable when there are multiple sessions with distinct concepts, not just one generic feature. Do these as separate chunks of work, then commit and push after each one.

​
Persistence

Suggested prompt:
Commit:

​
Duplicate Detection

Suggested prompt:
Commit:

​
Severity Badges

Suggested prompt:
Commit:
Now you have three distinct stories in history:
  • persistence
  • duplicate detection
  • severity filtering
That gives search much better material than a single vague feature.

​
Practice Skills

​
Explain

Ask:
Or:
What you should notice:
  • the skill is trying to connect the code to the original session context
  • this is different from a normal code explanation, which only describes current behavior

​
What Happened

Find a specific code range first:
Then ask:
What you should notice:
  • this is block-focused
  • it is about provenance of a specific region
  • it is ideal when a few lines look strange or surprising
Before this exercise, make sure entire login already worked in Terminal. search uses indexed checkpoint history, so give Entire a moment to index your pushed checkpoints before trying these queries. Start with a very specific query:
If that is too narrow, try:
Then try:
Only after that, try the broader question:
What you should notice:
  • it searches checkpoints, not just files
  • it helps with memory across sessions
  • it works best with concrete nouns and feature phrases, not broad words like persistence by itself
  • the best demo queries are feature names, validation behavior, bug text, file names, or ticket IDs

​
Session Handoff

Start with the summary request:
Or:
What you should notice:
  • the skill creates a concise handoff summary so another agent can pick up the next task
  • it is especially useful after a long build or debug session
For a more intentional transfer, use a two-step workflow. This example hands work to Claude Code, but you can replace Claude Code with any supported agent. Step 1: generate the handoff summary in your current agent:
Step 2: open the receiving agent and paste the handoff plus an explicit task brief:
This is the best tutorial pattern because it shows that:
  • session-handoff packages the important context
  • the user still controls the next objective
  • the receiving agent gets both history and clear execution instructions
If you want the receiving agent to stay narrowly scoped, make the brief even more explicit:

​
Why Skills Help

In this tutorial, Skill prompting is stronger than normal prompting because it gives the agent a defined workflow instead of a vague question.
/explain src/main.js is stronger than Why is this code here? because it tells the agent to investigate code intent with transcript-aware context.
what happened here: src/main.js:40-85 is stronger than Why is this weird? because it points to a specific block and asks for provenance.
search past work for duplicate bug detection is stronger than Have we done this before? because it gives the search Skill specific feature language to match.
Prepare a handoff for Claude Code... is stronger than summarize this because it names the receiving agent, the next task, and the key constraints.
The general pattern is simple:
  • Normal prompting asks the agent to guess the method
  • Skill prompting gives the agent both the goal and the method
That usually leads to better structure, better use of Entire history, and less back-and-forth.

​
Troubleshooting

Make sure:
  • the repo is installed in the right discovery path for your tool
  • the tool supports Skills or plugins
  • you are using prompts that clearly invoke the skill
Possible reasons:
  • the code was created outside an Entire-tracked session
  • you have not committed yet, or have not pushed yet for search
  • you have not enabled Entire in the repo
  • authentication or checkpoint configuration is incomplete
That usually means one of these:
  • the query is too broad, like persistence or auth
  • there are not enough prior sessions yet
  • your earlier sessions did not use distinctive feature language
To improve results:
  • use more specific queries like duplicate bug detection or severity badge filter
  • build 2 or 3 distinct features before testing the skill
  • commit and push after each feature so the history is easier to traverse and index
That usually means the project has too little tracked history. Do another meaningful work session, then commit it.