Sign in Subscribe

Looping

Software doesn’t stand still—it evolves. But the tools we use to manage that evolution are often disconnected, fragmented, or missing entirely.

Looping is a modular platform for software organizations. It connects architecture, teams, documentation, planning, operations, and experimentation into a single, navigable system.

At its core, Looping helps you run your software org like a product—evolving continuously while staying grounded in intent and context.

What Looping Helps You Understand

Teams often struggle to answer three foundational questions:

  1. What is this thing?
    Products, Components, Features, owners, docs, status, usage.
  2. Why does it work this way?
    Vision, Plans, Changes, experiments, decisions.
  3. What’s changing, and how healthy is it?
    Flags, incidents, metrics, rollouts, and documentation diffs.

Looping brings all of that into one structured, searchable, time-aware system.

The Canvas Is Where It Starts

The first experience in Looping is a canvas—a visual graph of your product and everything connected to it.

Looping's canvas isn't just a starting point. It becomes a living map of your organization—your architecture, your teams, your system, and your intent.

From the canvas, you can explore any Component or Feature, see its status and ownership, view recent Changes, or scrub through time to understand how and why it evolved.

Looping Modules

Looping is still in early development, but the vision is broad by design. The system is being built from the ground up to support a modular architecture—each part reinforcing the others, all connected by a shared product and org graph.

Below is an overview of where Looping is headed. Some of this is built. Some of it is actively in progress. And some of it is still being shaped through prototypes, writing, and feedback.

Core System

The foundation for everything in Looping.

It models your org, architecture, ownership, and workflows, giving every module shared context.

  • Org Directory — Teams, groups, people, reporting lines, and roles
  • Product Architecture — Products, Components, Features, and their dependencies
  • Ownership & Responsibilities — Map real-world teams to real systems
  • Workflow Engine — Webhooks, APIs, and callable commands tied to system events
  • VueFlow-Powered Graphs — Interactive navigation for org charts and product structure
  • Command Palette (CMD-K) — Search and trigger actions across the platform

Development

Looping’s planning and implementation system connects Vision, Plans, Changes, and Docs into a single navigable history of your product.

  • Vision Docs — Long-term goals tied to architecture and strategy
  • Plans — RFC-like documents linked to Features, Components, and Milestones
  • Changes — Structured Git-linked units of work enriched with AI summaries and documentation diffs
  • Versioned Documentation — Living docs that update automatically and can be viewed as-of any point in time
  • Git Replay — Import existing systems to generate a synthetic but structured change history

This module turns planning and implementation into a connected, explorable narrative—not just a pile of PRs.

Experiments

Feature flags and experimentation fully integrated with your product model.

  • Flags — Every Feature is rollout-ready by default, with toggles in code or UI
  • Cohorts — Static or dynamic segments built from customer traits or behavior
  • Experiments — Variants tied to Features with tracked goals, views, and conversions
  • Rollouts — Gradual exposure based on time, cohorts, usage, or performance
  • SDKs & APIs — Low-latency flag evaluation and event tracking from any platform

This isn’t just toggling features—Looping brings safety, insight, and context to the way you ship.

Operations

A real-time view of your system’s health and response workflows, tied to your product graph.

  • Gauges — Metrics like latency, error rate, or uptime tied to Components
  • Triggers — Thresholds that raise Incidents, notify owners, or create annotations
  • Incidents — Structured response with links to related Changes, Components, and Features
  • Annotations — Deploys, rollouts, or external events marked in the system timeline
  • Status Pages — Internal dashboards or public-facing pages showing current state
  • Meta-Services — Logical bundles of Components with health rolled up

Operations isn’t just observability—it’s organizational memory for what broke, what changed, and who responded.

This is a work in progress. Looping won’t ship with everything you see here on day one—but it’s the direction I’m building toward. And I’ll share updates along the way.

Not Just a Tool—A Context Graph

Looping isn’t a point solution. It’s a unified system that brings together the why, what, and how of software in one model.

That model helps:

  • Developers ship with confidence
  • PMs understand what’s live and what’s next
  • SREs connect symptoms to causes
  • Support see how systems behave over time
  • New hires onboard into context, not chaos
  • AI tools act with precision—not just prediction

Where I’m At

Looping is still early. The SaaS foundation is in place, and I’m actively building out the Core and Development systems. The full set of modules will come together over time.

If this vision resonates with you—whether you’re curious, skeptical, or just want to follow along—I’d love to hear from you. Feel free to read the blog or reach out directly.