FreeRide
← Back to docs

How It Works

Once FreeRide is connected, you don't need to learn a new workflow. You just need to understand what's available — and then you're freeriding. Ask your agent to capture, create, plan, search, document — anything related to your project knowledge. It all works through natural conversation.

The Session Flow

Every conversation follows a natural rhythm. FreeRide maps onto it without changing it.

Session starts → your agent gets oriented. The moment a conversation begins, your agent receives your project's current state — recent progress, feature status, open ideas, past decisions, existing documentation. No re-explaining. No hunting through files. The agent picks up where the last one left off.

You work on a feature → the agent loads context. Before diving into implementation, the agent gets everything relevant to that feature: open ideas, prior decisions, existing docs, which files belong to it. It doesn't duplicate decisions already made. It doesn't contradict existing architecture. It builds on what came before.

You make progress → it gets logged. After meaningful work — not every edit, but real milestones — progress is captured and tagged to the right feature. The system recognizes natural stopping points: committed code, passing builds, completed implementations. Minor tweaks and experiments don't clutter the log.

Session ends → everything is preserved. When you're done, just say "end session" — the agent writes a rich narrative summary of the conversation alongside the structured completion log. If the conversation ends unexpectedly — terminal closes, context fills up, you walk away — FreeRide detects it and closes the session on its own with a summary built from whatever was logged. Either way, nothing is lost.

What You Can Do

Once you understand what FreeRide offers, interacting with it is natural. Just tell your agent what you need:

Capture ideas. "We should add dark mode at some point" — captured as a backlog idea, attached to the right feature, prioritized. Your backlog builds itself from your natural thinking.

Record decisions. "Let's go with PostgreSQL because we need relational queries" or "Defer auth until after the design partner round" — choices logged with the reasoning. Architecture, scope, direction — whatever was decided, the why survives. Findable months later.

Create and update documents. "Write an implementation doc for the auth system" or "Update the architecture doc with the new API design" — knowledge documents that the agent maintains as part of the workflow. Seven document types: overview, implementation, architecture, guide, backlog, UX flow, vision.

Track features. "Let's track this as a new feature called Search" — features with status tracking (backlog → planned → in progress → done) that give your project structure.

Capture learnings. "That's interesting — so WebSocket connections don't work behind this type of proxy" — insights and discoveries preserved for future sessions.

Plan what's next. "What should I work on?" — your agent surfaces planned items, high-priority ideas, and in-progress features. You discuss, decide, and start building in the same conversation.

Search anything. "What did we decide about authentication?" or "Show me all the ideas for the dashboard" — everything is queryable. Decisions, ideas, progress, documents, learnings — all searchable across your entire project history.

Log progress. "Please log this work" — if the agent doesn't log automatically, you can always tell it to. You're in control of what gets recorded.

Skip what you don't want. "Don't start a session this time" or "Skip logging this work" — the agent listens and adapts. Nothing in FreeRide is forced; the agent decides what to call.

The point is: once you get the concept, you're freeriding. There's no syntax to memorize, no forms to fill. You think about your project out loud, and the system structures your thinking into organized, searchable, persistent knowledge.

What Gets Captured

Everything your agent captures is organized into your project's knowledge base:

  • Features — the major areas of your project, with status tracking. The natural boundaries around related work.
  • Ideas — thoughts captured during conversations. Belong to a feature or exist at the project level. Prioritized, searchable, plannable.
  • Completions — the record of work done. Tagged to features, timestamped, searchable. Your project's history.
  • Decisions — meaningful choices captured with their reasoning. Architecture, scope, direction — anything worth remembering. The answer to "why did we do it this way?"
  • Learnings — insights and knowledge gained during development. Concept explanations, debugging discoveries, things worth remembering.
  • Documents — rich markdown knowledge docs maintained by the agent. Implementation details, architecture notes, guides, vision docs.
  • Sessions — the record of every conversation, with summaries and what was accomplished.

Everything is connected. Ideas link to features. Completions tag to features. Decisions reference the context they were made in. Documents stay fresh because the agent updates them as work progresses.

How Ideas Become Work

One of the most natural flows in FreeRide:

  1. You have a thought mid-conversation — "we should also add export to CSV"
  2. The agent captures it — attached to the right feature, with priority
  3. It shows up on your dashboard — organized alongside other ideas, ready to review
  4. Next session, you plan — "what are the high-priority ideas?" → you pick what to build
  5. You build it — the agent loads the feature context and gets to work
  6. The idea closes — linked to the completion that resolved it

This cycle runs continuously. You think freely. The system turns your thinking into an organized, actionable backlog. No planning ceremonies. No ticket creation rituals. The planning and the building are the same conversation.

The Compounding Effect

FreeRide gets more valuable the more you use it. Session 1 has minimal context. Session 10 has a rich history. Session 50 has a comprehensive knowledge base that makes every new agent immediately productive.

Every idea captured is one less thing you need to remember. Every decision logged is reasoning you'll never have to reconstruct. Every document maintained is knowledge that survives beyond any single conversation.

Your project doesn't just grow in code. It grows in understanding.