AI Native Development

AI Native Development is a development paradigm in which the Session becomes a first-class unit of work: continuous, inspectable, and able to evolve with the project.

Point is a tool for this paradigm. The paradigm is larger than Point.

Development now happens in the Session

In a traditional workflow, most implementation happens in the developer's editor and terminal. Conversation supports the work, while the repository holds its durable record.

In AI Native Development, interaction is part of implementation. Intent, prompts, responses, actions, environment feedback, corrections, approvals, and failed attempts can all change what happens next. Their sequence matters.

The Session is that runtime record. Point does not prescribe a closed list of participants or event types; it preserves the original participant-visible event stream that an Agent integration can access and is allowed to save.

Context becomes versioned development history

Git remains the source of truth for repository state. AI Native Development adds a complementary context history with six properties:

• Complete. It retains the original participant-visible Session event stream in order.
• Durable. It survives the agent window in which it began.
• Addressable. A specific moment can be referenced directly.
• Continuable. Another participant can begin new work from that moment.
• Branchable. One origin can produce several independent explorations.
• Composable. A later Session can cite several prior Points as its sources.

Preservation and duplication are separate. Resume reconstructs the complete reachable Session lineage once, while a new Point stores only the events that happen after that boundary. Immutable parent references preserve everything behind it without transcript copies.

One project, two connected histories

The histories evolve independently:

• a context direction does not have to create a Git Branch;
• one Point can inform several Git Branches;
• several Points can inform one later Session;
• a Point can record the branch, commit, and worktree state visible when it was created;
• a Git Commit can link to the Point lineage that produced it.

This preserves both realities: repository history follows Git semantics, while context follows the actual shape of collaboration.

master represents the accepted context

Point uses a default context branch named master. The branch is a movable Ref; the Point it identifies remains immutable.

• Normal continuation. point resume opens the current master Tip.
• Historical reconstruction. point resume <point-id> opens an exact historical Point without moving master.
• Independent exploration. A named Point Branch keeps another direction addressable.
• Convergence. A new Session can use several Points as parents and advance master after a real decision is made.

Point master is independent from the repository's Git Branch. It describes the accepted context direction and can link to any Git Branch or Commit.

Sessions are becoming development infrastructure

The same direction is visible across the major Agent products:

• OpenAI Codex organizes Agent work into project Threads, preserves context while switching between parallel tasks, and carries Session history across the App, CLI, and IDE extension.
• GitHub Copilot treats Agent Sessions and logs as reviewable objects, links Commits back to Session logs, and supports sharing and querying history.
• Gemini CLI checkpoints the Git state, complete conversation history, and Tool call together. Its Session management supports Resume, Rewind, and Fork.
• VS Code Agent Sessions unifies local, background, and cloud work while preserving each Session's conversation history and Tool results.
• Claude Code persists project-scoped Sessions and supports Resume and Branch/Fork without changing the original.

The products differ in storage and scope, but they agree on the development unit: Session must survive, remain addressable, and be continuable. Point makes that history agent-neutral, project-owned, team-shareable, and transported through Git.

Local thought, stable team context

A working Session begins as local activity. point stash creates a continuation boundary independently of git commit. When a repository change is committed, the Commit integration can create a Local Commit Point linked to that Git Commit. Either local Point can be published with the source lineage it needs through the project's Git remote.

Push changes reachability, not identity. Unrelated local Points remain local.

Point implements the loop

Point makes the first complete AI Native Development loop practical:

1. Stash unfinished thought as a local continuation boundary.
2. Commit a project change and anchor the real Session that led to it.
3. Advance master or another Point Branch to the new immutable Point.
4. Resume a branch, an exact historical Point, or several parent Points.
5. Continue the work while preserving real parent relationships.
6. Publish the accepted branch and its parent graph through Git.

The CLI manages Git objects, refs, lineage, resume, and transport. The Skill teaches an agent when to use the CLI and supplies the Session that the participant is allowed to preserve. Different agents can collaborate without sharing a private runtime.

Intent is the next resolution

Session is the first versioned unit. The next layer identifies intent inside that Session: an exact expression, response, result, correction, or decision. Fine-grained references can connect intent to a project change without replacing the complete Session that gives it meaning.

The change

AI Native Development is not traditional development with a model added to the editor. Its working unit, collaboration surface, and history are different.

Git still tells us what changed in the repository. Context now travels with the work that changed it.