Build in Public League

Build with Entire

A content challenge for developers who build in public. Try Trails and Continuous Memory on a real project, then write about what you learned.

Sign up for Entire Explore Trails Explore Continuous Memory Read the quickstart

Entire at Build in Public League

Submissions

Dates and submission form to be announced

How it works: pick a topic, try it on a real project, and publish a post, video, or thread about what you found. Write for a developer who has never used Entire, and show your own work rather than repeating the docs.

We will announce dates, prizes, and the submission form here. In the meantime, start building and drafting.

01

What Is Entire?

Entire is the Git forge for agent-human collaboration. It keeps your code, the AI coding agent sessions that produced it, and your team’s decisions in one place, so people and agents can build on each other’s work.

This challenge is about two parts of Entire:

  • Trails replace the pull request for agentic coding. A Trail follows a piece of work from the intended outcome to merge: the code changes across one or more repositories, the agent sessions behind them, review agent scores and findings, CI results, and human approvals.
  • Continuous Memory is made of entire-graph and entire-brain. entire-graph gives your coding agent a map of how your code connects, and can cut token spend by up to 71%. entire-brain gives your repository a shared memory of past sessions, decisions, and lessons, so the next agent starts with that context, even when you switch from Claude Code to Codex.

Read the Entire docs

02

Features to Explore

Trails

Track work from intent to merge. A Trail holds the code changes across one or more repositories, the agent sessions behind them, review agent scores and findings, CI results, and human approvals. Gates decide when it can merge.

Continuous Memory

entire-graph and entire-brain working together: graph maps how your code connects and can cut token spend by up to 71%, brain remembers why it is that way. Start in Claude Code, finish in Codex, and the context carries over.

Sessions

The Entire CLI captures every coding agent session as you work: prompts, responses, tool calls, and token usage. Each commit links to the sessions behind it, so your readers can see how the code was written.

03

What to Write About

01

What Is Trails, and How Is It Different from a Pull Request?

Explain Trails to a developer who has only used pull requests. Cover intent before code, multi-repository changes, review agents scoring every push, and Gates. Use a real Trail from your project as the example.

02

Your First Trail, from Create to Merge

A step-by-step tutorial: enable Entire, run entire trail create, push, read the review agent results, fix the findings, and merge. Include the commands you ran and screenshots of each stage.

03

Taking a Trail from Red to Green

Show the loop between your coding agent and the review agents. Paste the Security or Slop findings, the fix your agent pushed, and how the scores changed over the last runs until they stabilized.

04

Write a Custom Review Agent for Your Codebase

Build an agent with your own instructions, such as a migration risk or accessibility check, and show the score and findings it reports on a real change.

05

Switch from Claude Code to Codex and Keep Your Project Context

Start a task in one agent and finish it in another. Show what entire-brain handed over: the decisions, rejected approaches, and saved memories, and what the second agent did with them.

06

How Many Tokens Did entire-graph Save Me?

Run the same tasks on a real repository with and without entire-graph. Share the numbers from entire graph stats, what changed in how your agent searched the code, and where it still needed help.

07

Give Your Repository a Memory

A practical guide to entire-brain: brief before a task, query for past decisions, and save a project rule with remember so you can recall it in a later session. Explain when you would use each one.

08

A Week of Building in Public with Entire

Keep a build log of a side project that uses Trails and Continuous Memory. Link the Trails and checkpoints behind each update so readers can follow how you built it.

Other

Feel free to be creative and impress!

04

Set Up Entire on Your Project

You need hands-on experience to write a good post. This takes about ten minutes.

  1. Sign up

    Sign up for Entire with GitHub and authorize the Entire GitHub App for the repository you want to use. A personal repository or a small side project works well.

  2. Install the CLI and enable Entire in your repository

    Shell
    # macOS/Linux
curl -fsSL https://entire.com/install.sh | bash

# Windows
irm https://entire.com/install.ps1 | iex

cd your-repo
entire login
entire enable --agent claude-code

    Replace claude-code with your agent: codex, cursor, copilot-cli, opencode, antigravity, factoryai-droid, or pi.

  3. Make a change with your agent and commit it

    Start a new agent session and ask for a small, focused change. Then commit it and choose yes when Entire asks to link the commit to the session.

    Shell
    git add path/to/changed-file
git commit -m "My first change with Entire"
entire checkpoint explain HEAD

    That commit is now a checkpoint: the code change paired with the prompt, transcript, and tool calls behind it. Full quickstart

05

Try Trails

Trails are Entire's replacement for the pull request in agentic coding. Review agents score every push, so you can tell when your coding agent and the reviewers have looped enough to merge.

  1. Check that Trails is on

    Trails is open to everyone. Open your repository in Entire and go to Settings → General: Trails is on by default.

  2. Turn on review agents

    Open your project's Agents page, select Manage Agents and enable the presets: Code review, Security review, and Slop, which catches sloppy patterns and drift. Each agent runs in its own cloud sandbox and reports a score from 0 to 100 with its reasoning and findings.

    Want something specific to your codebase? Select New agent and write your own instructions. Review agents

  3. Create a Trail

    Ask your coding agent to create one (it can run entire agent-help to learn the commands), or run:

    Shell
    entire trail create --title "Add account recovery"

    From a feature branch, this publishes the branch and links it to the Trail. Add --no-branch to capture the plan before writing any code.

  4. Push, read the findings, loop until green

    Each push runs the review agents. Every eval shows the current run next to the last five, so you can see when the scores settle. Hand the findings to your coding agent:

    Prompt
    Run `entire agent-help`, then inspect the Entire trail linked to
this branch. Summarize its intended outcome and open findings.
Check each finding against the code, propose fixes, and explain
any finding you think should be dismissed. Do not merge anything.

  5. Set Gates and merge

    In Settings → Gates, choose what must pass before merging: branch up to date, human approvals, unresolved agent findings above a severity, and CI checks. Once every blocking gate passes, select Merge. Gates

Screenshot each stage as you go. A Trail moving from red to green makes a strong post.

06

Try Continuous Memory

Continuous Memory is entire-graph and entire-brain working together: graph knows how your code connects, brain knows why it is that way. Continuous Memory

Aentire-graph: a map of your code

entire-graph analyzes your repository locally and maps files, symbols, callers, callees, and type usage. Your agent queries the map instead of grepping and reading whole files, which can save up to 71% in token spend. entire-graph does not send your code to a model or external service.

Shell
entire plugin install graph
entire graph setup --repo .
git add .entire/agent-guide.md AGENTS.md CLAUDE.md
git commit -m "Enable entire-graph"

Start a new agent session and ask: Use entire-graph to find where route matching is implemented and trace what calls it. Your agent should answer with specific file locations.

Measure what it saved

Shell
entire graph stats --repo .

This reads your local agent session transcripts and estimates the tokens entire-graph saved. Real numbers from your own project make a strong post. entire-graph docs

Bentire-brain: a memory for your repository

entire-brain brings saved agent sessions, checkpoints, project memories, docs, and code context from entire-graph into one memory. That memory belongs to the project, so any agent can use it.

Shell
curl -fsSL https://raw.githubusercontent.com/entireio/entire-brain/main/scripts/get-brain.sh | bash

cd your-repo
entire brain setup
entire brain status

Setup builds the repository's memory, installs a background watcher, and adds the agent instructions to AGENTS.md and CLAUDE.md. Commit the generated files and restart your agent.

Things to try and write about

Shell
entire brain overview                                  # what the project is and how it works
entire brain brief "add rate limiting to uploads"      # context before a task
entire brain query "why did we remove the queue"       # find past decisions
entire brain remember "Retry failed requests at most three times." --path constraints.retry.policy
entire brain recall "retry policy"
entire brain viz                                       # browse memory in a local UI

Then start a task in one agent and finish it in another, and show what carried over. entire-brain docs

07

Let Your Agent Help

Your coding agent can fix setup problems and look up the Entire docs for you, so you don't have to leave the terminal.

  1. Something not working? Ask your agent to run doctor

    If a session doesn't show up or checkpoints look wrong, ask your agent to run entire doctor. It checks the repository for stuck sessions, hook config drift and disconnected checkpoint branches, then reports each issue and how to fix it.

    Shell
    entire doctor

    Add --force to fix every issue without prompting. What doctor checks

  2. Give your agent the Entire docs

    The docs are served as an MCP server, so your agent can search them and answer questions about Entire while you build. For example, in Claude Code:

    Shell
    claude mcp add --transport http entire-docs https://docs.entire.io/mcp

    Not using MCP? Point your agent at docs.entire.io/llms.txt, an index of every docs page in Markdown.

08

How to Write a Great Post

The best posts answer a question other developers are asking, with proof from a real project.

Before you publish

Structure that works

  1. A title that is the question, like "How do I review code written by AI agents?" or "How can Claude Code and Codex share project context?"
  2. The answer first. Two or three sentences a reader could quote on their own, before any background.
  3. Headings phrased as questions, each followed by a direct answer and then the detail.
  4. Steps you can copy: numbered, with the exact commands in code blocks.
  5. Results: scores, findings, token counts, or before/after comparisons from your project.
  6. Where it fell short, and what you would do differently. Readers trust and share honest posts.

Get the facts right

  • Entire is the Git forge for agent-human collaboration. The Entire CLI is open source (MIT).
  • Trails replace the pull request for agentic coding. A Trail can start before any code exists and can span several repositories.
  • Review agents run in isolated cloud sandboxes on every push and report a score with a rationale and findings. Presets include Code review, Security review, and Slop.
  • Gates are a Trail's merge requirements: Up to date, Human review, Agent review, and Checks.
  • Trails is open to everyone. It is on by default in repository settings; there is no access form.
  • Continuous Memory is entire-graph plus entire-brain.
  • entire-graph runs locally, maps symbols and their relationships, traces callers and callees in 36 languages, and can cut token spend by up to 71%.
  • entire-brain is a memory layer that lives in the repository, so any agent can use it. Memories stay on your machine until you run entire brain connect.
  • A checkpoint links a Git commit to the agent session behind it: prompts, transcript, and tool calls.

Check anything else against the docs or the glossary, and ask us on Discord if you are unsure.

Link readers to Entire so they can try it themselves:

Links
Docs:              https://na2.hubs.ly/H08HbZn0
Quickstart:        https://na2.hubs.ly/H08Hc2b0
Trails:            https://na2.hubs.ly/H08HtbF0
Continuous Memory: https://na2.hubs.ly/H08JwRs0
Sign up:           https://na2.hubs.ly/H08HbZx0
09

Get Support

Stuck on setup, blocked by an error, or want a second opinion on your idea? Talk to us on Discord.

Entire community

Join the Entire Discord

Share what you built, get help after the hackathon, and hear about new releases first.

Join our Discord
10

Resources