# The Davenporter — full text index
Author: Jason Davenport (@davenportjw)
Canonical Base URL: https://davenporter.com

========================================================================
SECTION 1: PRODUCTION CODE BLUEPRINTS & SOURCE SNIPPETS
========================================================================

## Blueprint: cosm / topocosm — AST-Graph Native Source Control & Symbol Blast-Radius Locking
- Repository: https://github.com/davenportjw/cosm
- Language & Stack: Go / Python (AST Graph DB, Symbol Locks, topocosm Control Plane, Language Renderers)
- Summary: Flips traditional file based Git on its head for multi-agent engineering: the Abstract Syntax Tree (AST) graph is the primary source of truth, symbol-level leases prevent concurrent agent merge collisions, and files are materialized downstream for build tool compatibility.
- CLI Verification: `cosm universe inspect --symbol 'Router.Dispatch' --blast-radius --depth 2`
```python
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone


@dataclass(frozen=True)
class ASTSymbolNode:
    symbol_id: str
    qualified_name: str
    kind: str  # "Function" | "Method" | "Struct" | "Interface"
    signature_hash: str
    dependencies: tuple[str, ...] = field(default_factory=tuple)


class CosmUniverseGraph:
    """Agent-first AST graph universe with symbol-scoped locking and blast-radius traversal."""

    def __init__(self, universe_name: str) -> None:
        self.universe_name = universe_name
        self.nodes: dict[str, ASTSymbolNode] = {}
        self.active_leases: dict[str, tuple[str, datetime]] = {}

    def register_symbol(self, node: ASTSymbolNode) -> None:
        self.nodes[node.symbol_id] = node

    def compute_blast_radius(self, target_symbol: str, max_hops: int = 2) -> list[str]:
        """Return all upstream symbols impacted if `target_symbol` mutates."""
        reverse_edges: dict[str, set[str]] = {sid: set() for sid in self.nodes}
        for sid, node in self.nodes.items():
            for dep in node.dependencies:
                reverse_edges.setdefault(dep, set()).add(sid)

        visited: list[str] = []
        frontier = {target_symbol}
        for _ in range(max_hops):
            next_hop: set[str] = set()
            for current in frontier:
                for caller in reverse_edges.get(current, set()):
                    if caller not in visited and caller != target_symbol:
                        visited.append(caller)
                        next_hop.add(caller)
            frontier = next_hop
        return visited

    def acquire_surgical_lease(self, symbol_id: str, agent_id: str, ttl_seconds: int = 30) -> dict[str, object]:
        now = datetime.now(timezone.utc)
        lease = self.active_leases.get(symbol_id)
        if lease and lease[1] > now and lease[0] != agent_id:
            raise RuntimeError(f"Symbol {symbol_id} locked by {lease[0]} until {lease[1].isoformat()}")
        expires = now + timedelta(seconds=ttl_seconds)
        self.active_leases[symbol_id] = (agent_id, expires)
        return {
            "universe": self.universe_name,
            "symbol_id": symbol_id,
            "agent_id": agent_id,
            "blast_radius": self.compute_blast_radius(symbol_id),
            "expires_at": expires.isoformat(),
        }
```

## Blueprint: smartrouter — Policy-Driven Hybrid Router: Cloud Run Gemini 3.8 Flash + Local Gemma 4
- Repository: https://github.com/davenportjw/smartrouter
- Language & Stack: Python (Gemini 3.8 Flash, Gemma 4, Vertex AI ADC, FastAPI, Cost/Latency SLOs)
- Summary: Routes agent prompts dynamically between Google Cloud Vertex AI (Gemini 3.8 Flash / Gemini 3.5 Flash-Lite) and local Gemma 4 runners based on complexity score, context token budget, and data residency policy.
- CLI Verification: `uv run python -m smartrouter.cli --prompt 'Refactor AST graph lock lease expiry' --slo-ms 850`
```python
from dataclasses import dataclass
from typing import Literal


@dataclass(frozen=True)
class RoutingPolicy:
    project_id: str = "davenport-boutique"
    location: str = "us-central1"
    frontier_model: str = "gemini-3.8-flash"
    fast_cloud_model: str = "gemini-3.5-flash-lite"
    local_edge_model: str = "gemma-4-9b-it"
    complexity_threshold: float = 0.65


def select_execution_route(
    prompt_tokens: int,
    requires_tool_calling: bool,
    complexity_score: float,
    policy: RoutingPolicy = RoutingPolicy(),
) -> dict[str, str | float | Literal["cloud-frontier", "cloud-fast", "edge-gemma"]]:
    """Select optimal Gemini 3.8+ or Gemma 4 target using explicit SLO rules."""
    if requires_tool_calling or complexity_score >= policy.complexity_threshold or prompt_tokens > 8192:
        return {
            "tier": "cloud-frontier",
            "model": policy.frontier_model,
            "project": policy.project_id,
            "location": policy.location,
            "auth": "gcloud-adc",
            "rationale": f"High complexity ({complexity_score:.2f}) or tool synthesis required.",
        }
    if prompt_tokens > 2048:
        return {
            "tier": "cloud-fast",
            "model": policy.fast_cloud_model,
            "project": policy.project_id,
            "location": policy.location,
            "auth": "gcloud-adc",
            "rationale": "Medium context window routed to Gemini 3.5 Flash-Lite.",
        }
    return {
        "tier": "edge-gemma",
        "model": policy.local_edge_model,
        "project": policy.project_id,
        "location": "local-runner",
        "auth": "local-ipc",
        "rationale": "Compact classification task eligible for Gemma 4 runner.",
    }
```

## Blueprint: agentic-memory — Electric Sheep: Spanner Agent Memory Consolidation & AI Dream Cycles
- Repository: https://github.com/davenportjw/agentic-memory
- Language & Stack: Python / SQL (Cloud Spanner, MCP Server, Dream Consolidation, Crystallized Beliefs)
- Summary: Inspired by sleep-phase memory consolidation: episodic agent session trajectories are clustered offline during 'dream cycles' and promoted into high-confidence crystallized developer beliefs in Google Cloud Spanner.
- CLI Verification: `uv run python -m electric_sheep.dream --scope workspace --min-confidence 0.90`
```python
from dataclasses import dataclass


@dataclass(frozen=True)
class EpisodicObservation:
    session_id: str
    rule_candidate: str
    success_rate: float


@dataclass(frozen=True)
class CrystallizedBelief:
    belief_id: str
    statement: str
    confidence: float
    supporting_sessions: int
    scope: str = "global"


def consolidate_dream_cycle(
    observations: list[EpisodicObservation],
    min_sessions: int = 3,
    min_confidence: float = 0.90,
) -> list[CrystallizedBelief]:
    """Promote recurring episodic observations into crystallized Spanner beliefs."""
    grouped: dict[str, list[EpisodicObservation]] = {}
    for obs in observations:
        grouped.setdefault(obs.rule_candidate.strip(), []).append(obs)

    promoted: list[CrystallizedBelief] = []
    for idx, (statement, items) in enumerate(sorted(grouped.items()), start=1):
        unique_sessions = {i.session_id for i in items}
        if len(unique_sessions) < min_sessions:
            continue
        avg_score = sum(i.success_rate for i in items) / len(items)
        confidence = round(min(0.99, avg_score * (1.0 + 0.02 * len(unique_sessions))), 2)
        if confidence >= min_confidence:
            promoted.append(
                CrystallizedBelief(
                    belief_id=f"BELIEF-{idx:03d}",
                    statement=statement,
                    confidence=confidence,
                    supporting_sessions=len(unique_sessions),
                )
            )
    return promoted
```

## Blueprint: agent-telemetry — From Trajectories to Lineage: OpenTelemetry Span & Commit Provenance
- Repository: https://github.com/davenportjw/agent-telemetry
- Language & Stack: Python (OpenTelemetry, Cloud Trace, BigQuery Lineage, Trajectory Spans)
- Summary: Bridges the gap between ephemeral LLM reasoning traces and permanent repository commit history by binding OpenTelemetry span IDs, tool-call trajectories, and token budgets directly to AST/Git mutations.
- CLI Verification: `uv run python -m agent_telemetry.lineage --commit 9f41c8a2 --format summary`
```python
from dataclasses import dataclass
import hashlib


@dataclass(frozen=True)
class TrajectoryStepSpan:
    step_index: int
    tool_name: str
    duration_ms: float
    input_tokens: int
    output_tokens: int
    status: str = "OK"


def build_commit_lineage_manifest(
    commit_sha: str,
    model_name: str,
    spans: list[TrajectoryStepSpan],
) -> dict[str, object]:
    """Bind an agent trajectory span sequence to a deterministic lineage digest."""
    total_ms = round(sum(s.duration_ms for s in spans), 2)
    total_tokens = sum(s.input_tokens + s.output_tokens for s in spans)
    fingerprint_payload = f"{commit_sha}:{model_name}:{len(spans)}:{total_tokens}"
    lineage_id = hashlib.sha256(fingerprint_payload.encode("utf-8")).hexdigest()[:16]
    return {
        "lineage_id": f"lin_{lineage_id}",
        "commit_sha": commit_sha,
        "model": model_name,
        "step_count": len(spans),
        "total_duration_ms": total_ms,
        "total_tokens": total_tokens,
        "tools_invoked": [s.tool_name for s in spans],
    }
```

## Blueprint: warehouse-dash — Warehouse Dash: 10 Hz Authoritative Forklift Physics & Shard Telemetry
- Repository: https://github.com/davenportjw/warehouse-dash
- Language & Stack: TypeScript / Python (Cloud Run Shards, WebSockets, Isometric Canvas, Gemini 3.5 Flash-Lite)
- Summary: Regional Cloud Run simulation shards (`den-1`, `slc-2`, `phx-3`, `abq-4`) running an authoritative 10 Hz isometric forklift physics loop with `#dash` battery boost mechanics and AI bot fleet dispatch.
- CLI Verification: `curl -s -I https://warehouse-lobby-txgsracloq-uc.a.run.app | head -n 5`
```python
from dataclasses import dataclass


@dataclass
class ForkliftState:
    unit_id: str
    x: float
    y: float
    battery_pct: float = 100.0
    carrying_pallet: bool = False
    pallets_delivered: int = 0


def step_forklift_physics(
    state: ForkliftState,
    dx: float,
    dy: float,
    boost_active: bool,
    dt_sec: float = 0.1,
) -> ForkliftState:
    """Authoritative 10 Hz forklift movement & #dash battery consumption step."""
    can_boost = boost_active and state.battery_pct >= 8.0
    speed_multiplier = 1.85 if can_boost else 1.0
    base_speed = 4.2 if not state.carrying_pallet else 3.4

    new_x = max(0.0, min(24.0, round(state.x + dx * base_speed * speed_multiplier * dt_sec, 3)))
    new_y = max(0.0, min(16.0, round(state.y + dy * base_speed * speed_multiplier * dt_sec, 3)))

    if can_boost and (dx != 0 or dy != 0):
        battery = max(0.0, round(state.battery_pct - 14.0 * dt_sec, 1))
    else:
        battery = min(100.0, round(state.battery_pct + 4.5 * dt_sec, 1))

    return ForkliftState(
        unit_id=state.unit_id,
        x=new_x,
        y=new_y,
        battery_pct=battery,
        carrying_pallet=state.carrying_pallet,
        pallets_delivered=state.pallets_delivered,
    )
```

## Blueprint: nano-browser-agent — Browser-Native Agent: On-Device Gemini Nano & WebMCP
- Repository: https://github.com/davenportjw/the-davenporter
- Language & Stack: JavaScript / Web APIs (Chrome Built-in AI, LanguageModel, Summarizer API, document.modelContext, Vertex AI 3.8)
- Summary: Browser-native multi-turn docent architecture running on-device via Chrome's LanguageModel and Summarizer APIs. Uses document.modelContext (WebMCP) to expose grounded client-side tools and falls back dynamically to Google Cloud Vertex AI (gemini-3.8-flash) via Application Default Credentials.
- CLI Verification: `curl -s -X POST https://davenporter.com/api/agent/chat -H 'Content-Type: application/json' -d '{"prompt": "What is cosm?"}'`
```python
// 1. Probe & Warm Base Session via Chrome Prompt API
const capabilities = await self.LanguageModel?.availability();
const baseSession = await self.LanguageModel.create({
  initialPrompts: [{ role: "system", content: "You are The Davenporter Docent..." }]
});

// 2. Register Client-Side WebMCP Tools into document.modelContext
if ("modelContext" in document && typeof document.modelContext.registerTool === "function") {
  document.modelContext.registerTool({
    name: "search_davenporter_records",
    description: "Search essays, blueprints, and simulations",
    parameters: {
      type: "object",
      properties: { query: { type: "string" } },
      required: ["query"]
    },
    execute: async ({ query }) => searchCatalogRecords(query)
  });
}

// 3. O(1) Session Cloning for Turn Isolation & Safe Streaming
const turnSession = await baseSession.clone();
const stream = turnSession.promptStreaming("Explain cosm AST blast radius");
for await (const chunk of stream) {
  messageBodyElement.append(chunk); // textContent append only - zero innerHTML
}

// 4. Chrome Built-in Summarizer API
const summarizer = await self.Summarizer.create({ type: "key-points", length: "medium" });
const summaryStream = summarizer.summarizeStreaming(document.body.innerText);
```

========================================================================
SECTION 2: ESSAY SUMMARIES (21 ESSAYS)
========================================================================

### 100% of your developers should be building things to improve the workflow. Are they?
- URL: https://davenporter.com/writings/workflow-ownership-fix-the-machine
- Canonical Substack: https://davenporter.com/writings/workflow-ownership-fix-the-machine
- Published: Oct 21, 2026 (4 min read, 869 words)
- Tags: AI Strategy
- Social Card: https://davenporter.com/og/workflow-ownership-fix-the-machine.png
- Summary: Developers need to fix the machine, not the execution output. I was at a F500 sync in New York recently, and this idea came up: 100% of your developers should be building things to improve the workflow. So I asked the room how many of their team are actually doing the work.

### WIBTM: What happens when you let an agent design a new git system?
- URL: https://davenporter.com/writings/wibtm-what-happens-when-you-let-an
- Canonical Substack: https://davenporter.substack.com/p/wibtm-what-happens-when-you-let-an
- Published: Sep 24, 2026 (5 min read, 1069 words)
- Tags: WIBTM, Source Control
- Social Card: https://davenporter.com/og/wibtm-what-happens-when-you-let-an.png
- Summary: Why git and AST’s have some relationship, and what’s next when it comes to systems that are agent-first. If you’ve run many agents together on a single repo, you quickly realize that the volume of agentic code can break git.

### The value of being bored in the AI and attention economy
- URL: https://davenporter.com/writings/the-value-of-being-bored-in-the-ai
- Canonical Substack: https://davenporter.substack.com/p/the-value-of-being-bored-in-the-ai
- Published: Sep 16, 2026 (3 min read, 718 words)
- Tags: AI Strategy
- Social Card: https://davenporter.com/og/the-value-of-being-bored-in-the-ai.png
- Summary: And how it can keep us in the high value areas of AI engineering. First, I hate being bored. I grew up in the era of the internet, and subsequently the attention economy, so I’m well accustomed to having something to distract myself.

### What happens AI burns down the backlog?
- URL: https://davenporter.com/writings/what-happens-ai-burns-down-the-backlog
- Canonical Substack: https://davenporter.substack.com/p/what-happens-ai-burns-down-the-backlog
- Published: Sep 03, 2026 (5 min read, 1128 words)
- Tags: AI Strategy
- Social Card: https://davenporter.com/og/what-happens-ai-burns-down-the-backlog.png
- Summary: AI is still a business transformation problem, and its out-kicking the product coverage. In a session a few weeks back someone presented me an interesting problem for developers and practitioners: What happens when developers using AI burn down the backlog?

### From trajectories to lineage: building better agent telemetry
- URL: https://davenporter.com/writings/from-trajectories-to-lineage-building
- Canonical Substack: https://davenporter.substack.com/p/from-trajectories-to-lineage-building
- Published: Aug 27, 2026 (3 min read, 554 words)
- Tags: Agent Telemetry
- Social Card: https://davenporter.com/og/from-trajectories-to-lineage-building.png
- Summary: A conceptual map of how to establish provenance for agent decisions using the existing tools we have today. In agent analysis and tracking, traces and trajectories are becoming well established for understanding a particular decision, or a session of decisions and events that an agent makes.

### Is the future of learning ‘vibe’ training?
- URL: https://davenporter.com/writings/is-the-future-of-learning-vibe-training
- Canonical Substack: https://davenporter.substack.com/p/is-the-future-of-learning-vibe-training
- Published: Aug 25, 2026 (9 min read, 1860 words)
- Tags: Source Control, AI Strategy
- Social Card: https://davenporter.com/og/is-the-future-of-learning-vibe-training.png
- Summary: Unpacking how we teach non-determinism in a 30 second attention span economy. Have you stopped and asked yourself during a training or after the question: what did I actually get out of this? That question probably gets harder to answer the longer the training is.

### WIBTM: Add telemetry and observability to your AI agents
- URL: https://davenporter.com/writings/add-telemetry-and-observability
- Canonical Substack: https://davenporter.substack.com/p/add-telemetry-and-observability
- Published: Aug 18, 2026 (5 min read, 1118 words)
- Tags: WIBTM, Source Control, Agent Telemetry
- Social Card: https://davenporter.com/og/add-telemetry-and-observability.png
- Summary: Telemetry and observability give you the means to start capturing data that make your agent systems long running, and improve their capabilities over time. Most agent examples start with agent instructions, a model, and a few tools, and end there.

### WIBTM: Give an agent access to memories created with AI dreams
- URL: https://davenporter.com/writings/give-an-agent-access-to-memories
- Canonical Substack: https://davenporter.substack.com/p/give-an-agent-access-to-memories
- Published: Aug 12, 2026 (4 min read, 941 words)
- Tags: WIBTM, Memory Systems
- Social Card: https://davenporter.com/og/give-an-agent-access-to-memories.png
- Summary: I gave this talk at AI4 on how to create a memory system for your agents to dream, sharing here in the long form. Philip Dick wrote a short story titled ‘Do robots dream of electric sheep?’. I slightly changed this title for a talk I gave titled ‘Do agents dream of binary sheep?’.

### The State of AI in the SDLC: A Roadmap for Scaling
- URL: https://davenporter.com/writings/ai-sdlc-scaling-framework
- Canonical Substack: https://davenporter.substack.com/p/ai-sdlc-scaling-framework
- Published: Jul 01, 2026 (6 min read, 1265 words)
- Tags: Source Control, AI Strategy
- Social Card: https://davenporter.com/og/ai-sdlc-scaling-framework.png
- Summary: AI innovation is messy when you're trying to ship. Here are some practical things I've found to integrate AI into your software development lifecycle, from your first customer to your thousandth. A common question I hear these days is ‘how does someone else use AI?’.

### Moving Past "Demos Over Memos": The Future of AI in Enterprise Product Development
- URL: https://davenporter.com/writings/emos-over-memos-enterprise-ai
- Canonical Substack: https://davenporter.substack.com/p/emos-over-memos-enterprise-ai
- Published: Jun 24, 2026 (4 min read, 906 words)
- Tags: Source Control, AI Strategy
- Social Card: https://davenporter.com/og/emos-over-memos-enterprise-ai.png
- Summary: Vibe coding and pure prototypes are creating cognitive overload. Here is how enterprise engineering teams must restructure for long-term AI success. I often use the analogy that AI is the equivalent in the workplace of taking the box of 96 crayons, representing the packaging of tasks by role, and throwing the box on the floor.

### How to Track AI Agent Lineage and Manage State in Code Repositories
- URL: https://davenporter.com/writings/how-to-track-ai-agent-lineage-and
- Canonical Substack: https://davenporter.substack.com/p/how-to-track-ai-agent-lineage-and
- Published: Jun 16, 2026 (6 min read, 1287 words)
- Tags: Source Control, Agent Telemetry
- Social Card: https://davenporter.com/og/how-to-track-ai-agent-lineage-and.png
- Summary: Moving beyond clean git commits to knowledge systems for agentic development. “Keep your git commits clean. It’s a goal for everyone, but we always struggle to actually do it. I don’t have enough fingers and toes to count in my individual commits when I’ve tried to fix something and the commit messages become fix and really fixed.

### WIBTD/W/M: A fool's folly with local AI models
- URL: https://davenporter.com/writings/wibtdwm-a-fools-folly-with-local
- Canonical Substack: https://davenporter.substack.com/p/wibtdwm-a-fools-folly-with-local
- Published: Jun 11, 2026 (6 min read, 1234 words)
- Tags: WIBTM, Model Routing, AI Strategy
- Social Card: https://davenporter.com/og/wibtdwm-a-fools-folly-with-local.png
- Summary: Failures, learnings, and hopefully good next steps to being realistic about developing AI models and methods. When I originally come up with the ‘What I built this ….’ concept, it was about sharing things I built that I thought might be useful with the community make AI and cloud computing things easier.

### With AI, what's old is new in telemetry again
- URL: https://davenporter.com/writings/with-ai-whats-old-is-new-in-telemetry
- Canonical Substack: https://davenporter.substack.com/p/with-ai-whats-old-is-new-in-telemetry
- Published: Jun 09, 2026 (4 min read, 802 words)
- Tags: Agent Telemetry
- Social Card: https://davenporter.com/og/with-ai-whats-old-is-new-in-telemetry.png
- Summary: Why tracing is critical to improving your AI experiences. I remember a demo with an observability vendor back in 2019. We were setting up a big data app, and they showed us a cool topology map of a request, how it flowed through multiple API’s, and ultimately queried a database we were configuring.

### WIBTD/W/M: Routing AI responses between local runners
- URL: https://davenporter.com/writings/wibtdml-routing-ai-responses-between
- Canonical Substack: https://davenporter.substack.com/p/wibtdml-routing-ai-responses-between
- Published: Jun 04, 2026 (5 min read, 1108 words)
- Tags: WIBTM, Source Control, Model Routing
- Social Card: https://davenporter.com/og/wibtdml-routing-ai-responses-between.png
- Summary: Extending smartrouter to support calling local AI models that are a part of a pool of workers, learnings and tribulations, and things I'm planning to do next. I’ve been fascinated with local models more and more recently. These are the open models you can download and run on your laptop.

### What's worth learning in an AI era?
- URL: https://davenporter.com/writings/whats-worth-learning-in-an-ai-era
- Canonical Substack: https://davenporter.substack.com/p/whats-worth-learning-in-an-ai-era
- Published: Jun 02, 2026 (4 min read, 736 words)
- Tags: AI Strategy
- Social Card: https://davenporter.com/og/whats-worth-learning-in-an-ai-era.png
- Summary: How AI has changed the question from how to learn quickly to if learning will be useful. I grew up when the internet in the US was just beginning its widespread adoption and I remember the first time we got high speed internet (we were the first on the block).

### What I'm building this week: Route your Gemini API calls on your terms
- URL: https://davenporter.com/writings/what-im-building-this-week-route
- Canonical Substack: https://davenporter.substack.com/p/what-im-building-this-week-route
- Published: May 28, 2026 (3 min read, 577 words)
- Tags: WIBTM, Source Control, Model Routing
- Social Card: https://davenporter.com/og/what-im-building-this-week-route.png
- Summary: A little router I'm building and improving to use different Gemini (and soon other) models. A question I’ve received a few times recently is how companies can route Gemini API calls based on their own rules and specs. This usually includes a few things.

### Can you 'learn' to use AI without being all in?
- URL: https://davenporter.com/writings/can-you-learn-to-use-ai-without-being
- Canonical Substack: https://davenporter.substack.com/p/can-you-learn-to-use-ai-without-being
- Published: May 26, 2026 (8 min read, 1662 words)
- Tags: Source Control, AI Strategy
- Social Card: https://davenporter.com/og/can-you-learn-to-use-ai-without-being.png
- Summary: Explorations about successful learning patterns for AI and how I'm using it currently. A common pattern I’ve witnessed with developers and leaders over the past 3-6 months goes something like the following. Someone is told they should ‘try AI’ or has some mandate without a goal.

### What I'm building this week(/month/quarter)
- URL: https://davenporter.com/writings/what-im-building-this-weekmonthquarter
- Canonical Substack: https://davenporter.substack.com/p/what-im-building-this-weekmonthquarter
- Published: May 21, 2026 (2 min read, 396 words)
- Tags: WIBTM
- Social Card: https://davenporter.com/og/what-im-building-this-weekmonthquarter.png
- Summary: This week: How agent skills are improving my session workflows. I’m working on a demo that I’m hoping to share next week. This week’s ‘build’ focuses on where I’ve created a new agent skill in my workflow that helps manage my session information and make my life a little easier.

### AI and the New Business Moat: Defending Your Competitive Advantage
- URL: https://davenporter.com/writings/ai-and-the-new-business-moat-defending
- Canonical Substack: https://davenporter.substack.com/p/ai-and-the-new-business-moat-defending
- Published: May 19, 2026 (5 min read, 1036 words)
- Tags: Source Control, AI Strategy
- Social Card: https://davenporter.com/og/ai-and-the-new-business-moat-defending.png
- Summary: AI requires you to create another moat of advantage. Here are my thoughts about how to do it. I’m fortunate enough each year to lead a number of Google engineers as we build our keynotes. These activities take a lot of time.

### 'Dark data' is your new most valuable data for AI
- URL: https://davenporter.com/writings/dark-data-is-your-new-most-valuable
- Canonical Substack: https://davenporter.substack.com/p/dark-data-is-your-new-most-valuable
- Published: May 13, 2026 (3 min read, 623 words)
- Tags: AI Strategy
- Social Card: https://davenporter.com/og/dark-data-is-your-new-most-valuable.png
- Summary: And why big data is making a comeback to bring data out of the shadows that your agents need in order to be successfully created and trained. Someone asked me a question the other day related to generative AI (because why not AI), and it went something like ‘what do you think is going to be the next trend here in 6 to 12 months?’.

### Maximizing Developer Value: Using AI Across the Entire Code Lifecycle
- URL: https://davenporter.com/writings/maximizing-developer-value-using
- Canonical Substack: https://davenporter.substack.com/p/maximizing-developer-value-using
- Published: Jul 10, 2025 (6 min read, 1298 words)
- Tags: AI Engineering
- Social Card: https://davenporter.com/og/maximizing-developer-value-using.png
- Summary: There’s now a wealth of information and tutorials floating around about how you can go from 0 to 1 with AI, or even vibe code personalized apps or prototypes? But what’s next, and how do we use AI effectively across all parts of our coding development?

========================================================================
SECTION 3: UNIFIED CHRONOLOGY (42 EVENTS)
========================================================================
- [Oct 21, 2026] [SUBSTACK · THE DAVENPORTER] 100% of your developers should be building things to improve the workflow. Are they?: Developers need to fix the machine, not the execution output. (/writings/workflow-ownership-fix-the-machine)
- [Oct 21, 2026] [CLOUD RUN · US-CENTRAL1] Shipped revision 15 of this site: I pushed the fifteenth revision of this site to Cloud Run. (https://the-davenporter-txgsracloq-uc.a.run.app)
- [Oct 20, 2026] [CLOUD RUN · US-CENTRAL1] Shipped revision 51 of the Warehouse Dash lobby: I deployed the 51st revision of the Warehouse Dash lobby, the server that matches players into games. (https://warehouse-lobby-txgsracloq-uc.a.run.app)
- [Oct 20, 2026] [CLOUD RUN · US-CENTRAL1] Launched this site: I put the first version of this site on Cloud Run, with my essays, code notes, and the arcade in one place. (https://the-davenporter-txgsracloq-uc.a.run.app)
- [Oct 16, 2026] [CLOUD RUN · US-CENTRAL1] Launched the Warehouse Dash lobby: I launched the online lobby for Warehouse Dash, my forklift game, so people can play together in the browser. (https://warehouse-lobby-txgsracloq-uc.a.run.app)
- [Oct 13, 2026] [GITHUB · @DAVENPORTJW] Updated agentic-memory: Spanner-backed agent memory consolidation & dream cycle crystallization (Electric Sheep). (https://github.com/davenportjw/agentic-memory)
- [Oct 13, 2026] [GITHUB · @DAVENPORTJW] Updated agent-skills: Reusable operational skills, TDD gates, and adversarial rater protocols for coding agents. (https://github.com/davenportjw/agent-skills)
- [Oct 07, 2026] [GITHUB · @DAVENPORTJW] Updated agent-memory: Episodic trajectory storage and scoped retrieval primitives for autonomous developer agents. (https://github.com/davenportjw/agent-memory)
- [Oct 02, 2026] [GITHUB · @DAVENPORTJW] Updated 30-years-of-chat: Interactive historical retrospective and protocol evolution of chat & agentic interfaces. (https://github.com/davenportjw/30-years-of-chat)
- [Oct 01, 2026] [CLOUD RUN · US-CENTRAL1] Shipped revision 3 of Aetheria: I deployed the third revision of Aetheria, my small 3D world that runs in the browser. (https://open-world-threejs-txgsracloq-uc.a.run.app)
- [Sep 29, 2026] [CLOUD RUN · US-CENTRAL1] Launched Aetheria: I put Aetheria, a 3D world built with Three.js, on Cloud Run so it can be played from the arcade page. (https://open-world-threejs-txgsracloq-uc.a.run.app)
- [Sep 29, 2026] [GITHUB · @DAVENPORTJW] Updated cosm: A graph version of a git-like experience (https://github.com/davenportjw/cosm)
- [Sep 24, 2026] [SUBSTACK · THE DAVENPORTER] WIBTM: What happens when you let an agent design a new git system?: Why git and AST’s have some relationship, and what’s next when it comes to systems that are agent-first. (/writings/wibtm-what-happens-when-you-let-an)
- [Sep 16, 2026] [GITHUB · @DAVENPORTJW] Updated topocosm: The control plane for a shared cosm service (https://github.com/davenportjw/topocosm)
- [Sep 16, 2026] [SUBSTACK · THE DAVENPORTER] The value of being bored in the AI and attention economy: And how it can keep us in the high value areas of AI engineering. (/writings/the-value-of-being-bored-in-the-ai)
- [Sep 15, 2026] [GITHUB · @DAVENPORTJW] Updated recursive-model: Experiments in recursive self-improvement and multi-step verification loops. (https://github.com/davenportjw/recursive-model)
- [Sep 11, 2026] [GITHUB · @DAVENPORTJW] Updated agentic-fashion: Multi-modal styling and boutique catalog synthesis on Vertex AI. (https://github.com/davenportjw/agentic-fashion)
- [Sep 03, 2026] [SUBSTACK · THE DAVENPORTER] What happens AI burns down the backlog?: AI is still a business transformation problem, and its out-kicking the product coverage. (/writings/what-happens-ai-burns-down-the-backlog)
- [Aug 27, 2026] [SUBSTACK · THE DAVENPORTER] From trajectories to lineage: building better agent telemetry: A conceptual map of how to establish provenance for agent decisions using the existing tools we have today (/writings/from-trajectories-to-lineage-building)
- [Aug 25, 2026] [SUBSTACK · THE DAVENPORTER] Is the future of learning ‘vibe’ training?: Unpacking how we teach non-determinism in a 30 second attention span economy. (/writings/is-the-future-of-learning-vibe-training)
- [Aug 18, 2026] [SUBSTACK · THE DAVENPORTER] WIBTM: Add telemetry and observability to your AI agents: Telemetry and observability give you the means to start capturing data that make your agent systems long running, and improve their capabilities over time. (/writings/add-telemetry-and-observability)
- [Aug 12, 2026] [SUBSTACK · THE DAVENPORTER] WIBTM: Give an agent access to memories created with AI dreams: I gave this talk at AI4 on how to create a memory system for your agents to dream, sharing here in the long form. (/writings/give-an-agent-access-to-memories)
- [Aug 05, 2026] [GITHUB · @DAVENPORTJW] Updated agent-telemetry: Trajectory-to-lineage OpenTelemetry instrumentation binding spans to repository commits. (https://github.com/davenportjw/agent-telemetry)
- [Jul 01, 2026] [SUBSTACK · THE DAVENPORTER] The State of AI in the SDLC: A Roadmap for Scaling: AI innovation is messy when you're trying to ship. Here are some practical things I've found to integrate AI into your software development lifecycle, from your first customer to your thousandth. (/writings/ai-sdlc-scaling-framework)
- [Jun 24, 2026] [SUBSTACK · THE DAVENPORTER] Moving Past "Demos Over Memos": The Future of AI in Enterprise Product Development: Vibe coding and pure prototypes are creating cognitive overload. Here is how enterprise engineering teams must restructure for long-term AI success. (/writings/emos-over-memos-enterprise-ai)
- [Jun 16, 2026] [SUBSTACK · THE DAVENPORTER] How to Track AI Agent Lineage and Manage State in Code Repositories: Moving beyond clean git commits to knowledge systems for agentic development. (/writings/how-to-track-ai-agent-lineage-and)
- [Jun 11, 2026] [SUBSTACK · THE DAVENPORTER] WIBTD/W/M: A fool's folly with local AI models: Failures, learnings, and hopefully good next steps to being realistic about developing AI models and methods (/writings/wibtdwm-a-fools-folly-with-local)
- [Jun 09, 2026] [SUBSTACK · THE DAVENPORTER] With AI, what's old is new in telemetry again: Why tracing is critical to improving your AI experiences (/writings/with-ai-whats-old-is-new-in-telemetry)
- [Jun 08, 2026] [GITHUB · @DAVENPORTJW] Updated smartrouter: a simple router to demonstrate how to layer capabilities on top of AI API's (https://github.com/davenportjw/smartrouter)
- [Jun 04, 2026] [SUBSTACK · THE DAVENPORTER] WIBTD/W/M: Routing AI responses between local runners: Extending smartrouter to support calling local AI models that are a part of a pool of workers, learnings and tribulations, and things I'm planning to do next (/writings/wibtdml-routing-ai-responses-between)
- [Jun 02, 2026] [SUBSTACK · THE DAVENPORTER] What's worth learning in an AI era?: How AI has changed the question from how to learn quickly to if learning will be useful. (/writings/whats-worth-learning-in-an-ai-era)
- [May 28, 2026] [SUBSTACK · THE DAVENPORTER] What I'm building this week: Route your Gemini API calls on your terms: A little router I'm building and improving to use different Gemini (and soon other) models. (/writings/what-im-building-this-week-route)
- [May 26, 2026] [SUBSTACK · THE DAVENPORTER] Can you 'learn' to use AI without being all in?: Explorations about successful learning patterns for AI and how I'm using it currently (/writings/can-you-learn-to-use-ai-without-being)
- [May 21, 2026] [SUBSTACK · THE DAVENPORTER] What I'm building this week(/month/quarter): This week: How agent skills are improving my session workflows (/writings/what-im-building-this-weekmonthquarter)
- [May 19, 2026] [SUBSTACK · THE DAVENPORTER] AI and the New Business Moat: Defending Your Competitive Advantage: AI requires you to create another moat of advantage. Here are my thoughts about how to do it. (/writings/ai-and-the-new-business-moat-defending)
- [May 19, 2026] [GITHUB · @DAVENPORTJW] Updated cloud-code-vscode: Cloud Code for Visual Studio Code: Issues, Documentation and more (https://github.com/davenportjw/cloud-code-vscode)
- [May 13, 2026] [SUBSTACK · THE DAVENPORTER] 'Dark data' is your new most valuable data for AI: And why big data is making a comeback to bring data out of the shadows that your agents need in order to be successfully created and trained. (/writings/dark-data-is-your-new-most-valuable)
- [Apr 13, 2026] [GITHUB · @DAVENPORTJW] Updated devrel-demos: This repo is for code that supports talks, blogs, and other activities the Google Cloud Developer Relations team engages in. (https://github.com/davenportjw/devrel-demos)
- [Apr 06, 2026] [GITHUB · @DAVENPORTJW] Updated terraform-google-analytics-lakehouse: Deploys a Lakehouse Architecture Solution (https://github.com/davenportjw/terraform-google-analytics-lakehouse)
- [Feb 10, 2026] [GITHUB · @DAVENPORTJW] Updated human-tests: No description on GitHub. (https://github.com/davenportjw/human-tests)
- [Jan 28, 2026] [GITHUB · @DAVENPORTJW] Updated cloud-run-tutor: No description on GitHub. (https://github.com/davenportjw/cloud-run-tutor)
- [Jul 10, 2025] [SUBSTACK · THE DAVENPORTER] Maximizing Developer Value: Using AI Across the Entire Code Lifecycle: There’s now a wealth of information and tutorials floating around about how you can go from 0 to 1 with AI, or even vibe code personalized apps or prototypes? (/writings/maximizing-developer-value-using)