# Claude Opus Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/claude-opus
> Markdown URL: https://aitinkerers.org/technologies/claude-opus.md
> Technology record last updated: 2026-09-18T15:13:41Z
> Generated: 2026-09-20T20:42:42Z

Claude Opus: Anthropic's flagship large language model, delivering frontier intelligence for complex reasoning, advanced coding, and autonomous agentic workflows.

Claude Opus is Anthropic's most capable foundation model (LLM), setting the industry benchmark for complex reasoning, math, and coding. It achieves state-of-the-art results on key evaluations: Opus 4.1 scored 74.5% on SWE-bench Verified. The model features a massive 200,000-token context window (expandable to 1 million for specialized tasks), enabling deep, multi-file analysis and long-horizon agentic workflows. Deploy Opus for enterprise-grade automation, complex financial forecasting, or expediting R&D across critical sectors.

- Official technology site: https://claude.ai/
- Public AI Tinkerers demos and talks: 18
- Result page: 1 of 1

## Recent Public Talks and Demos

### [AI for Feels, Not Just Tasks](https://la.aitinkerers.org/talks/rsvp_d3x3AU8Ehzk)

Glad to present how I'm going about building this emotional gps for AI - basically a tool that helps you get emotional clarity in 5 minutes. It's not therapy - it's in between group chat and therapy. Users type in what's hard to say. The app using AI shows images for visual projection to surface emotional patterns, and then it reflects back what could really be going on, what you actually want and what you're prepared to do about it. Happy to present a demo of the working product, then go into the file architecture, my workflow and unit economics for API calls.

- Event context: Aug 16 - AI Tinkerers LA: Beauty, Bytes, and Venice Beach Vibes 🌊✨🤖 — Los Angeles
- Public talk page: https://la.aitinkerers.org/talks/rsvp_d3x3AU8Ehzk

### [Your BD Pipeline Is A Good First Autonomous Agent](https://boston.aitinkerers.org/talks/rsvp_Vjy6qYY7UX0)

An end-to-end BD pipeline that runs itself on a weekly cron: it sources leads, researches them, drafts the outreach, and emails me the two or three things to do this week. Sourcing → research → draft → nudge, with a lightweight CRM to run it from. One rule holds everywhere: the system researches and drafts; a human always sends. Why this is worth five minutes of a GTM room’s time: almost every agent demo shows one primitive at a time — here’s tool use, here’s a cron, here’s memory. That leaves you knowing the parts and not the shape. BD is a workflow everyone in this room already has opinions about, which makes it a good place to see the whole surface area doing real work at once. The demo is a guided tour of that: I trace one target end to end, and name the primitive earning its keep at each step. The tour, following one company through the system: It gets found. The Opportunity Radar treats my ICP as a graph rather than a list. It starts from private-equity sponsors active in my space and walks outward — a locked sub-agent maps each fund’s portfolio in parallel threads, and qualified portfolio companies auto-feed the pipeline. The frontier of unvisited sponsors lives in a memory store, so the walk resumes each Monday instead of cold-starting. Ownership structure is what makes a buyer resemble my last buyer, so the graph edge qualifies better than a keyword match. It gets carded. The Radar pushes the target into my CRM over MCP — the CRM is itself an MCP server, so the agents and I drive the same pipeline through the same tools. It gets researched. A graded session produces a seven-section pre-call brief off the live web. The run ships with a rubric; the platform scores the deliverable and sends the agent back to revise before I see it. The verdict lands on the card. It gets formatted. Skills load the output contract on demand — including a bundled validate_blocks.py the agent runs against its own draft so the CRM can parse the people and portfolio blocks. It gets drafted. A nightly cron drafts outreach from a compiled brand pack. Secrets come from a vault injected at egress — the agents never see a key. It stops. The draft sits at the gate. Nothing sends. Pipeline status is never machine-written. What I’ll show live: the Monday-morning board with fit scores and grader verdicts that arrived without me; one target’s drawer opened — why-now, signals, key people, dossier, draft; the sweep receipt showing what the Radar covered and where it stopped; a rubric and the revision it forced; and the eval scorecard where a prompt change shows up as a delta against a pinned baseline.

- Event context: Back from Summer: AI GTM Builders — 2026-09-03 — Boston
- Public talk page: https://boston.aitinkerers.org/talks/rsvp_Vjy6qYY7UX0

### [Verification with LLM powered Behavior Driven Development (BDD)](https://seattle.aitinkerers.org/talks/rsvp_abgJncjsLmk)

At SageOx, we've built test tooling that has raised the conceptual level of E2E tests from traditional code to human natural language. We've married the old idea of BDD (Behavior Driven Development) with LLMs to reduce the cognitive debt of designing and reviewing acceptance criteria for agent generated code. In my demo, I will show you a test scenario can be defined using natural language in the Gherkin format, have a coding agent turn that into a test run plan that exercises our Web UI, CLI and integration in Claude Code. And, then show a trace of the test running against these multiple interfaces in a single pleasing test report.

- Event context: AI Dev Tools Track - Seattle - July 13 — 2026-07-14 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_abgJncjsLmk

### [Graph-Oriented Generation: Deterministic Context Retrieval for Code](https://manchester-nh.aitinkerers.org/talks/rsvp_SMbTB_Lslqs)

GOG (Graph-Oriented Generation) is a deterministic context-retrieval system for code generation: instead of embedding chunks and pulling them by similarity, it parses the codebase into an AST-derived graph and traverses it to assemble precise context for a prompt. Live, I'll run the same prompt through Claude Code two ways — vanilla, and with GOG injecting context — and walk the full path from the initial prompt, through decomposing the project structure into stratum relationships, to the actual AST graph traversal that selects what the model sees. You'll see the retrieval working, not a slide about it.

- Event context: AI Tinkerers Manchester (Bedford), NH - June 2026 Meetup — 2026-06-17 — Manchester NH
- Public talk page: https://manchester-nh.aitinkerers.org/talks/rsvp_SMbTB_Lslqs

### [Consistent UI at Scale](https://seattle.aitinkerers.org/talks/rsvp_EX9uQGBltNs)

I'm a design systems lead. My team got dramatically faster with AI agents, but without guardrails the speed produced a mess with custom styles, one-off components, and inconsistent UX patterns. UI updates became disproportionately hard, and even though we shipped more, quality and consistency dropped, and with that, the user experience worsened. I saw this pattern happening in our team, and on my personal projects, and as a designer, didn't like it at all. I decided to find a way to guide agents to follow design system standards. So I ran an experiment to figure out what kind of documentation and prompting actually keeps agents on-pattern. I used the same component library, same models, but three documentation conditions (none, CLAUDE.md + supporting markdown, and a custom Skill + JSDoc) crossed with three prompt styles. One combination produced 95% fewer style violations against the none-documented version. Agents stopped reinventing components and started reusing them, which allowed the system to maintain itself effectively. New work began reinforcing existing patterns instead of eroding them. When new components or patterns were actually needed, agents started proposing them rather than building unique, one-off elements.

- Event context: GTM / Growth Track - Seattle — 2026-05-27 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_EX9uQGBltNs

### [FuzzyClaw](https://cologne.aitinkerers.org/talks/rsvp_71A8QTW9ocg)

FuzzyClaw is an agent orchestration platform that turns markdown briefings into coordinated multi-agent work. A coordinator agent interprets the briefing, dispatches specialist agents running in isolated Docker containers, and routes their outputs into PostgreSQL, where they can be reviewed through a Django dashboard. Agents, the coordinator, and the human operator communicate in real time via a Redis-backed message board. The project is written in Python and draws inspiration from Steinberg’s OpenClaw and Qwibit.ai’s nanoclaw, with a strong focus on visibility, control, and practical day-to-day use.

- Event context: AI Tinkerers Cologne 4: Live Technical Demos — 2026-04-16 — Cologne
- Public talk page: https://cologne.aitinkerers.org/talks/rsvp_71A8QTW9ocg

### [Experience Vibing with metaMe](https://nyc.aitinkerers.org/talks/rsvp_fPIx41io4cs)

metaMe is a registry-driven agent runtime and studio that dynamically composes AI interfaces and experiences from structured context rather than fixed screens. For the demo, I’ll show how the metaMe Runtime, Studio, and Registry work together to generate live experience surfaces based on three active layers of context: persona, agent/model, and cartridge/codex. Instead of treating UI as a hardcoded frontend, the system resolves registry-defined primitives, policies, and active agents into runtime behavior such as smart menus, prompt surfaces, trust indicators, and domain-specific experience states. The demo will focus on the implementation: how context is modeled, how the runtime is hydrated, how dynamic rendering decisions are made, and how secure agent/tool execution is routed.

- Event context: March Demo Day, hosted by Flowglad — 2026-03-18 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_fPIx41io4cs

### [Metadata Driven AI Pipelines](https://seattle.aitinkerers.org/talks/rsvp_3eYiO5c3fGw)

Long running tasks are always a balance of control and agency. As we slowly move away from the CLI to task managers (Jira, Linear, Beads, etc) we will need to figure out ways to find a good balance between control and agency. If control is pure code and agency is purely agentic, then AI pipelines look to be something in between. Code that executes and validates LLM output, but relies on the intelligence of the model to do a majority of the work. I will show how I am designing the AI pipelines and using metadata from a task manager (Linear in this case) to control which pipeline executes for different types of tasks (bugs, features, etc)

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — March 9th, 2026 — 2026-03-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_3eYiO5c3fGw

### [Using AI to Build Production Grade Mobile Apps](https://san-diego.aitinkerers.org/talks/rsvp_K3TaJybd13w)

I will demo how I built Bizzie, a production-grade stock market app, by leveraging an AI-augmented pipeline from design to deploy. This isn't a "Hello World" demo; it’s a look at how to use AI to enforce Clean Architecture and enterprise standards (on par with a Fortune 100 company). The Stack & Flow: Design-to-UI: Using Figma Make + Figma MCP to bridge the gap between design tokens and production Flutter code. Agentic Engineering: Managing a fleet of specialized AI Agents (Antigravity) to scaffold CI/CD, write unit tests, and enforce strict architectural patterns. Accessibility: Leveraging Stark’s AI for adherence to WCAG 2.2 AA. What I’ll Show: I’ll run the app live and dive into my IDE (Antigravity) to show the "messy" reality of agentic development. You’ll see exactly where AI excels (boilerplate/scaffolding) and the specific hacks required to make it output Fortune 100-level code quality.

- Event context: AI Tinkerers San Diego: February Meetup at Google — 2026-02-27 — San Diego
- Public talk page: https://san-diego.aitinkerers.org/talks/rsvp_K3TaJybd13w

### [SQAAILab - Software Quality Assurance & Artificial Intelligence Laboratory. (This is pronounced SKYLAB - first American space station in 1973 :) )](https://montreal.aitinkerers.org/talks/rsvp_y9vu-klDzzM)

1. I will briefly explain my goal with this laboratory. 2. Then demonstrate, through some QUICK concrete examples, how I proceed. 2.1 Prompting (RCTFET Style) 2.2 Vibe Coding 2.3 Doc Generation 2.4 Analysis Assistance 2.5 Test Generation

- Event context: AI Tinkerers Montreal - February 2026 Meetup — 2026-02-24 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp_y9vu-klDzzM

### [OpenClaw-Powered Port: Turning a Figma Plugin into a Standalone Web App with Claude + Grok](https://tokyo.aitinkerers.org/talks/rsvp_WdjiLvvXPiU)

I'll demo how I migrated Humation — a hand-drawn avatar system used by 60k+ people — from Figma Plugin to standalone web app using ONLY AI agents via OpenClaw (Claude Opus + Grok). No manual coding: I'll live-show the prompts, iterative generations, debugging hacks, SVG handling quirks, performance fixes, and unexpected failures/successes that made it work. Core logic remains simple part-layering, but AI handled the entire porting chaos.

- Event context: AI Tinkerers Tokyo - Toranomon Meetup - February 19, 2026 — 2026-02-19 — Tokyo
- Public talk page: https://tokyo.aitinkerers.org/talks/rsvp_WdjiLvvXPiU

### [Custom Self Improving Subagents with Claude Code](https://seattle.aitinkerers.org/talks/rsvp_Hc7X3ifdjnw)

Most Claude Code setups are static—your agents do the same thing every time. But what if they could learn from their own execution? In this talk, I'll demo a self-improving subagent architecture running in Claude Code that uses a plan→build→improve cycle where agents update their own knowledge after every workflow, maintains expertise.yaml files (500-1000 lines per domain) that evolve based on real execution patterns, and shares learnings across domains via a collective knowledge registry so when one agent discovers something, all agents can benefit. Live demo: I'll show agents improving themselves in real-time, including the .shared/ folder pattern for cross-domain knowledge propagation.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — February 9th, 2026 — 2026-02-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_Hc7X3ifdjnw

### [How to build good skills for LLMs](https://dhaka.aitinkerers.org/talks/rsvp_CJHoJK54W44)

Skills are the SOTA for providing capabilities to LLMs while making sure to not flood the context with all the tokens tools/ MCPs do. In this talk I will present some rules of thumb for building skills that LLMs will use and use well, sourced from Anthropic’s guidance, their course and my on-the-ground experience writing skills for my own use.

- Event context: AI Tinkerers Dhaka 2nd Meetup: Dhaka Builds with AI! — 2026-02-07 — Dhaka
- Public talk page: https://dhaka.aitinkerers.org/talks/rsvp_CJHoJK54W44

### [Write Once, Prompt Anywhere: Architecting Portable, Dynamic Interfaces for LLMs](https://san-diego.aitinkerers.org/talks/rsvp_E83764oLLm8)

Standard chat interfaces are silos. We're all maintaining separate lists of "golden prompts" and manually editing placeholders like [INSERT CONTEXT] every time we switch between Claude, ChatGPT, or Gemini. This talk covers the engineering behind SidePC, a provider-agnostic browser extension built to treat prompts as portable, structured assets. I will perform a hands-on code walk-through (vanilla JS/Manifest V3) focusing on the implementation of our portable prompt schema (.sidepc). This JSON-based architecture enables more than just text storage; it supports recursive folder hierarchies and dynamic variable tokenization. I’ll dive into the regex engine used to transform raw strings into interactive form inputs (dropdowns, file uploads) and the DOM injection logic required to bypass Content Security Policies (CSP) while simulating trusted events for React/Vue-based UIs. We’ll also examine the "Remote Sync" system that utilizes a Base ID versioning strategy, allowing teams to treat prompt libraries like Git repos for auto-updating team-wide workflows.

- Event context: AI Tinkerers San Diego: January Meetup — 2026-01-23 — San Diego
- Public talk page: https://san-diego.aitinkerers.org/talks/rsvp_E83764oLLm8

### [Practical LLM Integration: Lessons from Building a SEC Filing Analysis Project](https://houston.aitinkerers.org/talks/rsvp_Vt9RZstb_VY)

A live coding demo walking through an LLM-powered document analysis system. I'll run the pipeline live and show the code that makes it work. Using regex and rule-based filters to reduce LLM API costs by 80%+ Extracting structured data from unstructured documents with Claude Implementing semantic caching with Qdrant to avoid redundant API calls Tracking LLM costs and latency with Langfuse

- Event context: AI Tinkerers Houston: Working Code, Live Demos, and Architectures for 2026 — 2026-01-13 — Houston
- Public talk page: https://houston.aitinkerers.org/talks/rsvp_Vt9RZstb_VY

### [Agents That Fix Their Own Mistakes: Multi-Agent Code Generation with Automated Iteration](https://seattle.aitinkerers.org/talks/rsvp_RqWmfQqo1uY)

Forge solves the fundamental problem with AI code generation: tools generate fast but have **no quality control, no institutional memory, and can't fix their own mistakes**. Every generation starts from scratch with the same errors repeating. This demo shows a multi-agent orchestration system where specialized AI agents coordinate to produce **production-ready code through intelligent iteration**. Testing agents run security scans, performance benchmarks, and functional tests. When tests fail, review agents analyze root causes and coordinate generation agents to apply fixes using a library of **28 proven architecture patterns**. The system loops until all tests pass—**automatically**. You'll see the complete workflow: plain English requirements decomposed into tasks, parallel code generation using KnowledgeForge patterns, automated testing that catches real issues, AI-powered diagnosis tracing failures to root causes, and iterative fixes applied until the codebase is deployable. The live demo shows **actual test failures, the diagnostic reasoning, and automated remediation in under 60 seconds**. This isn't prompt engineering or chat interfaces. It's **agents managing agents**—planning, generating, testing, diagnosing, fixing, and deploying **without human intervention** between requirement and production-ready result. Built with Claude Sonnet 4, Docker-isolated testing, and semantic search across engineering patterns. **Open source, working production tool, building real applications today**.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — January 12th, 2026 — 2026-01-13 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_RqWmfQqo1uY

### [Building Working Code Live: Documentation-First AI Development](https://seattle.aitinkerers.org/talks/rsvp_ctw_B2iINIQ)

I'll demonstrate the spawn-experiments methodology - a systematic approach to AI-assisted code generation using documentation-first prompting with Claude models (Sonnet 4 and Opus) through Claude Code's Task tool. Live demo: building a functional CLI tool from scratch in real-time, showing how structured specifications generate better AI outputs than vague prompts. Based on spawn-experiments research comparing 4 AI development methodologies across multiple experiments, findings show methodology significantly impacts AI development patterns and outcomes, with trade-offs between development speed and code quality. You'll see the actual "code-like prompting" techniques that treat prompts as executable specifications, parallel code generation across multiple threads, and comprehensive quality control including syntax validation, automated test generation, and real-time error handling.

- Event context: AI Tinkerers Seattle September Meetup — September 30, 2025 — 2025-10-01 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_ctw_B2iINIQ

### [Curating memory and knowledge via MCP](https://seattle.aitinkerers.org/talks/rsvp_QR5SDgviogU)

Showing off our new Zine application, which is both a model-agnostic MCP client, and an MCP server for sharing curated knowledge with other MCP clients. With Zine, you can use any model with tool-calling support, including the latest OpenAI GPT-5, Claude Opus 4.1 and Gemini 2.5 Pro. In the demonstration, I will: - link one or more accounts (Google, GitHub, etc.) - create data sources to ingest from Gmail, GitHub Issues, Slack, etc. - curate the ingested data into a saved 'view' - share this view as a remote MCP server with Claude Desktop and an AI coding agent like Cursor - retrieve data from Zine, via the MCP tools/resources, from a MCP client like Claude Destkop

- Event context: Summer on the Lake - August Tinkerers Meetup! (Demos, Food, Friends) — 2025-08-28 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_QR5SDgviogU

## Related Technologies

- [React](https://aitinkerers.org/technologies/react) ([Markdown](https://aitinkerers.org/technologies/react.md)) — 219 public demos
- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 214 public demos
- [GPT-5](https://aitinkerers.org/technologies/gpt-5) ([Markdown](https://aitinkerers.org/technologies/gpt-5.md)) — 30 public demos
- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 662 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 173 public demos
- [Claude Sonnet](https://aitinkerers.org/technologies/claude-sonnet) ([Markdown](https://aitinkerers.org/technologies/claude-sonnet.md)) — 20 public demos
- [Next](https://aitinkerers.org/technologies/next) ([Markdown](https://aitinkerers.org/technologies/next.md)) — 186 public demos
- [Pytest](https://aitinkerers.org/technologies/pytest) ([Markdown](https://aitinkerers.org/technologies/pytest.md)) — 6 public demos
- [Supabase](https://aitinkerers.org/technologies/supabase) ([Markdown](https://aitinkerers.org/technologies/supabase.md)) — 90 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 205 public demos
- [Anthropic](https://aitinkerers.org/technologies/anthropic) ([Markdown](https://aitinkerers.org/technologies/anthropic.md)) — 36 public demos
- [@anthropic-ai/sdk](https://aitinkerers.org/technologies/anthropic-ai-sdk) ([Markdown](https://aitinkerers.org/technologies/anthropic-ai-sdk.md)) — 2 public demos
- [Antigravity](https://aitinkerers.org/technologies/antigravity) ([Markdown](https://aitinkerers.org/technologies/antigravity.md)) — 6 public demos
- [Beads](https://aitinkerers.org/technologies/beads) ([Markdown](https://aitinkerers.org/technologies/beads.md)) — 7 public demos
- [ChatGPT](https://aitinkerers.org/technologies/chatgpt) ([Markdown](https://aitinkerers.org/technologies/chatgpt.md)) — 83 public demos
- [Claude Agents SDK](https://aitinkerers.org/technologies/claude-agents-sdk) ([Markdown](https://aitinkerers.org/technologies/claude-agents-sdk.md)) — 4 public demos
- [Claude Managed Agents](https://aitinkerers.org/technologies/claude-managed-agents) ([Markdown](https://aitinkerers.org/technologies/claude-managed-agents.md)) — 2 public demos
- [Claude skills and hooks](https://aitinkerers.org/technologies/claude-skills-and-hooks) ([Markdown](https://aitinkerers.org/technologies/claude-skills-and-hooks.md)) — 1 public demo