Pensieve

Recent Notes

See 75 more →

San Francisco Dev Tools Meetup — AI Developer Workflows

8 min read

Meetup notes from a San Francisco developer tools event focused on AI-powered coding workflows, agent orchestration, and shipping code with LLMs.

WorkOS — TARS: Identity-Aware AI Agents

Speaker: WorkOS team

WorkOS demoed TARS, an internal AI agent platform that operates as a closed-loop agentic system. The core idea: get AI agents out of developers’ local machines and into the cloud, where they can operate autonomously.

Key Concepts

  • Closed-loop agentic experience: The agent is prompted, writes code, validates it, and inspects results without the developer needing to manually review or run anything locally.
  • Event-driven triggers: Agents can be kicked off by webhooks, contracts, or quick ad-hoc tasks.
  • MCP-connected services: TARS connects to Linear, GitHub, Snowflake, and other internal services via MCP. This means engineers can tap into tools they don’t use day-to-day, and non-engineers (sales, GTM) can open pull requests and file issues using the same context engineers have.

Identity & Credentials

  • TARS uses the user’s own credentials, not a service account. When it opens a PR on Linear, it’s assigned to you and authenticated as you.
  • This is powered by WorkOS Pipes — their own product for authenticating as your users on third-party services. Just a couple lines of code to keep the identity mapping surface clean.
  • Hooks power the interaction layer: commenting on Linear, back-and-forth with the agent during development, and taking actions on behalf of the user.

Takeaway

If you need to authenticate as your users on separate services in your own app, WorkOS Pipes is worth a look.

OpenSpec + Caskless + Iterate PR — A Minimalist AI Dev Flow

Speaker: Unnamed founder

A deliberately austere dev workflow built on three pillars: specification, guardrails, and automated iteration.

1. OpenSpec — Specification-Driven Development

OpenSpec is a set of skills and commands that take structured inputs before any code is written:

  • What are you trying to build?
  • Why are you building it?
  • Who is it for?
  • What are the design considerations?

It generates a set of spec files including design documents (context, system touchpoints) and durable task lists. Agents love durable task lists — they’re great at checking boxes and working through them sequentially. This is especially valuable for large changes like refactoring from an array-based pattern to a class-based design.

2. Caskless — Deterministic AI Guardrails

AI makes mistakes, and Caskless prevents it from making the same mistake twice. It creates deterministic static analysis rules based on tree-sitter that act as hard constraints.

Example: In a TypeScript-heavy codebase, any is a forbidden word. Claude loves substituting undefined for any, which is effectively just any in a trench coat. Caskless creates rules that say “don’t do this anymore” — things you might allow in a prototype but never in production code.

3. Iterate PR — Automated CI Loop

A skill (originally from Sentry) that hammers on your GitHub PR using the GitHub CLI until everything goes green. It checks CI status, reviews AI code reviewer feedback, and keeps looping (uv run loop) until all tests and checks pass.

The Flow

OpenSpec (what & why) → Caskless (never do this again) → Iterate PR (CI must pass)

This allows them to ship a high volume of code to production at a high quality bar.

Ralph Loops — Telegram-Driven Agent Orchestration

Speaker: Ralph

A personal automation setup built around Claude Code, Ghosty terminal, and bun.js loops.

Problem

Running Claude Code sessions meant constant babysitting — lots of shells open, lots of waiting. Before --remote existed, Ralph needed a notification system.

Solution Stack

  • Telegram bot hooked into Claude Code for push notifications and control.
  • Ghosty terminal with workspace memory — it remembers your layouts, supports a socket for automation, and has a built-in browser.
  • CMUX (not tmux) — a workspace manager on top of Ghosty with different workspace configurations.
  • Bun.js loop — a simple iteration loop that reads a task file, picks the most important task, executes it via the Anthropic API, and commits. That’s the entire loop.

Git Worktrees for Parallel Work

For large monorepos where you want to work on multiple features simultaneously without agents conflicting:

  • A script reads a task file, creates a new workspace, runs git worktree, opens a new tab, hooks in, and moves on to the next feature.
  • This keeps each agent isolated in its own worktree.

CMUX — Multiplexed Agent Workspaces

Speaker: CMUX founders

CMUX is an unopinionated terminal workspace manager with vertical tabs, split panes, a built-in browser, and a CLI that wraps everything together.

Features

  • Vertical tabs showing: workspace name, current branch, one-liner of what the agent is doing, active ports, and PR status.
  • CLI integration: Everything is connected. You can tell Claude Code to spawn new workspaces, add browser panes, or perform any action via CLI.
  • HQ mode: A control center concept where you can send information between terminals, manage GitHub issues, and orchestrate agents.

Workflow Pattern

  • Use Claude Code as a manager agent and Codex as implementer agents.
  • Claude Code spawns Codex instances across terminals, each working on a separate issue.
  • Supports both git worktree and multiple git clone approaches — unopinionated by design.
  • The CLAUDE.md file tells Claude how to create worktrees and workspaces.

Stats

  • Almost 12k GitHub stars at time of demo.

Containerized Dev Environments (Coast)

Speaker: CMUX team (continued)

A containerized approach to parallel development using a tool called Coast.

How It Works

  • Each worktree or feature gets its own container.
  • Shared services (Postgres, Redis) run on the host machine and are reused across containers — no duplication.
  • You can switch between worktrees by checking out different containers on localhost:3000.
  • Agents (like Codex) can spin up their own containerized environments autonomously.

Example Command

coast "Make a version of the site where it replaces CSS for post-dev with hot green, goes green, and is assigned to dev three"

Remote deployment support was described as days away at the time of the talk.

Rook — An Autonomous Engineering Agent

Speaker: Unnamed founder (SF startup, 11 engineers)

Rook is an autonomous agent built on Claude that handles the full feature development lifecycle.

What Rook Does

  1. Builds a feature
  2. Runs it locally
  3. Records a video of it working
  4. Opens a pull request
  5. Runs CI to make sure everything passes
  6. Responds to code review comments

Adoption & Impact

  • Introduced to the team in February.
  • Slack integration launched March 2nd.
  • As of the talk, Rook has written 89% of PRs at the company — largely displacing other background agents, but also some human-written code.
  • Excellent at using custom Slack emoji.
  • Has a distinct personality (unlike most LLM products).
  • Accessible via Slack, making it easy for non-engineers to interact with.

Extended Capabilities

  • Access to logs, session replay, and a read replica database.
  • Can order groceries for the London office (yes, really).
  • Designers can screenshot UI issues, @ Rook, and get a fix PR back with CI passing.
  • During the Axios supply chain attack, the founder was able to ask Rook from bed whether they were affected and got an immediate, accurate answer.

Name Origin

“Because then I can say ‘Rook is cooking’ and ‘Rook, take a look.’”

Anti-Pattern Czar — Claude MD Best Practices

Speaker: Unnamed

A talk about the speaker’s personal CLAUDE.md instruction set — a minimal but opinionated set of rules to keep Claude’s code quality high.

The Rules

1. Don’t Build It Until You Need It

Claude has a habit of proactively building things you haven’t asked for. Resist this. Only extract patterns after the second duplication, never before.

If you DRY too early, you get similar-but-not-identical functions scattered across the codebase. When Claude tries to reuse them, nothing connects properly.

2. Keep It Simple

Write the obvious solution first. Optimize only if needed. Claude tends to over-engineer.

3. Delete Aggressively

Claude will write a new function, then another, then another — seven versions of the same thing, only using the last one. Delete the rest. You have Git; you can always get it back.

4. Semantic Naming

Always name variables, parameters, and API endpoints with verbose, self-documenting names that optimize for comprehension by both humans and LLMs, not brevity.

Example:

  • waitUntilObservationIsSaved = true (good — self-instructing)
  • wait = true (bad — ambiguous)

Example:

  • stkSessionId vs claudeSessionId — Claude kept confusing which was the primary agent and which was the memory agent until the names were made explicit.

Semantic naming is more tokens, but dramatically more context. Variable names become self-instructing for the LLM.

Resend Agents — Quick Note

  • Design your agent APIs to have different return values for agents vs. actual users.

Common Themes

  • Claude Code and MCP are the backbone of most workflows.
  • Durable task lists and spec-first development keep agents on track.
  • Deterministic guardrails (static analysis, tree-sitter rules) prevent repeat mistakes.
  • Git worktrees are the preferred pattern for parallel agent work.
  • Identity-aware agents (using real user credentials, not service accounts) are becoming standard.
  • Automated CI loops (Iterate PR pattern) let agents self-correct until checks pass.
  • Semantic naming is a surprisingly high-leverage practice for LLM-assisted codebases.

Linked Map of Contexts

Development, Artificial Intelligence

Graph View