diff --git a/.DS_Store b/.DS_Store
deleted file mode 100644
index 175ed52..0000000
Binary files a/.DS_Store and /dev/null differ
diff --git a/.gitignore b/.gitignore
index ca1d169..a4af3b7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
node_modules
.next
-.claude
\ No newline at end of file
+.claude
+.DS_Store
\ No newline at end of file
diff --git a/app/globals.css b/app/globals.css
index df45aee..47cfde0 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -2,10 +2,23 @@
@tailwind components;
@tailwind utilities;
+/* Screen reader only utility */
+.sr-only {
+ position: absolute;
+ width: 1px;
+ height: 1px;
+ padding: 0;
+ margin: -1px;
+ overflow: hidden;
+ clip: rect(0, 0, 0, 0);
+ white-space: nowrap;
+ border-width: 0;
+}
+
body {
margin: 0;
padding: 0;
- background-color: #151515;
+ background-color: #0a0a0b;
overflow: hidden;
height: 100vh;
width: 100vw;
diff --git a/app/heartbeat/page.tsx b/app/heartbeat/page.tsx
new file mode 100644
index 0000000..3d9a740
--- /dev/null
+++ b/app/heartbeat/page.tsx
@@ -0,0 +1,276 @@
+"use client";
+
+export default function Heartbeat() {
+ return (
+
+
+
+
+
+ );
+}
diff --git a/app/jan2026/layout.tsx b/app/jan2026/layout.tsx
new file mode 100644
index 0000000..979d85c
--- /dev/null
+++ b/app/jan2026/layout.tsx
@@ -0,0 +1,57 @@
+import type { Metadata } from "next";
+
+export const metadata: Metadata = {
+ title: "Jan 2026 Dinner | Continuous AI",
+ description: "San Francisco · January 2026",
+ openGraph: {
+ type: "website",
+ title: "Continuous AI Dinner",
+ description: "San Francisco · January 2026",
+ url: "https://continuousai.com/jan2026",
+ siteName: "Continuous AI",
+ images: [
+ {
+ url: "/og-image.gif",
+ width: 1200,
+ height: 630,
+ alt: "Continuous AI",
+ },
+ ],
+ },
+ twitter: {
+ card: "summary_large_image",
+ title: "Continuous AI Dinner",
+ description: "San Francisco · January 2026",
+ images: ["/og-image.gif"],
+ },
+};
+
+export default function Jan2025Layout({
+ children,
+}: {
+ children: React.ReactNode;
+}) {
+ return (
+ <>
+
+ {children}
+
+ );
+}
diff --git a/app/jan2026/page.tsx b/app/jan2026/page.tsx
new file mode 100644
index 0000000..064d8f0
--- /dev/null
+++ b/app/jan2026/page.tsx
@@ -0,0 +1,794 @@
+"use client";
+
+import { useEffect, useState } from "react";
+
+export default function Jan2025Page() {
+ const [loaded, setLoaded] = useState(false);
+
+ useEffect(() => {
+ setLoaded(true);
+ // Partner context for the generated prompt
+ const partners: Record = {
+ linear: { name: 'Linear', role: 'issue tracking', desc: 'Issues can trigger AI workflows, get auto-triaged, and dispatch to coding agents', category: 'planning' },
+ launchdarkly: { name: 'LaunchDarkly', role: 'feature flags & AI configs', desc: 'Manage AI model configs, prompts, and rollouts with the same controls you use for feature flags', category: 'release' },
+ snyk: { name: 'Snyk', role: 'security scanning', desc: 'Vulnerability alerts can trigger automated patching, testing, and PR creation', category: 'security' },
+ notion: { name: 'Notion', role: 'documentation', desc: 'Block-based architecture gives AI structured context—every paragraph, task, and property is queryable', category: 'knowledge' },
+ continue: { name: 'Continue', role: 'mission control for AI agents', desc: 'Ship faster with Continuous AI—orchestrate cloud agents, automate workflows, and measure what matters', category: 'agents' },
+ devin: { name: 'Devin', role: 'async AI engineer', desc: 'Cloud coding agent that can work on tasks asynchronously and push PRs', category: 'agents' },
+ jules: { name: 'Jules', role: 'proactive coding agent', desc: 'Suggests tasks, runs scheduled jobs, integrates with deployments—AI that works without being asked', category: 'agents' },
+ sentry: { name: 'Sentry', role: 'error monitoring', desc: 'Errors can trigger automated investigation, fixes, and deploys', category: 'observability' },
+ datadog: { name: 'Datadog', role: 'observability', desc: 'AI agents can query logs, traces, metrics, and incidents through natural language', category: 'observability' },
+ posthog: { name: 'PostHog', role: 'product analytics', desc: 'Track AI feature usage: token costs, latency, and user satisfaction', category: 'analytics' },
+ vercel: { name: 'Vercel', role: 'deployment platform', desc: 'AI can investigate anomalies, review code, and create PRs from production insights', category: 'deployment' },
+ confluent: { name: 'Confluent', role: 'data streaming', desc: 'Event-driven AI that perceives, reasons, and acts as events unfold in real-time', category: 'data' },
+ cognee: { name: 'Cognee', role: 'context engineering', desc: 'Knowledge graphs and vector search give AI the right information at the right time', category: 'data' },
+ graphene: { name: 'Graphene', role: 'AI-native BI', desc: 'BI with semantic layers that lives in your repo and AI agents can query via CLI', category: 'analytics' },
+ github: { name: 'GitHub', role: 'code hosting', desc: 'PRs, issues, actions, and Codespaces can all be automated by AI', category: 'code' },
+ sanity: { name: 'Sanity', role: 'content platform', desc: 'Structured content with schemas AI can understand—typed, relational data', category: 'content' },
+ dlthub: { name: 'dltHub', role: 'data pipelines', desc: 'Python library for declarative data loading that AI agents can use to move data between systems', category: 'data' },
+ };
+
+ // Multi-tool questions: forward-looking questions about Continuous AI
+ // Randomly selected when multiple tools are chosen
+ const multiToolQuestions = [
+ // About the shift from reactive to proactive
+ "What would change if your tools started acting on their own instead of waiting for you to ask?",
+ "What's something you check manually every day that could just tell you when it needs attention?",
+ "If your systems could fix routine problems overnight without waking anyone, what would you trust them to handle first?",
+ "What work would disappear from your plate if your tools could remember context from yesterday?",
+
+ // About measuring and trusting automation
+ "How would you know if AI automation is actually helping versus creating new problems to manage?",
+ "What would make you comfortable letting AI merge code without your approval?",
+ "At what point does reviewing AI output become more work than doing the task yourself?",
+ "What's the difference between AI that saves you time and AI that just shifts where you spend it?",
+
+ // About connecting systems
+ "What information lives in one tool that would be more valuable if it automatically flowed somewhere else?",
+ "What decisions get delayed because they require checking three different systems first?",
+ "If all your tools shared the same memory, what would you want them to remember?",
+ "What falls through the cracks because no single system sees the whole picture?",
+
+ // About progressive autonomy
+ "What's something AI should suggest today but do automatically in a year?",
+ "Where would you want AI to start with training wheels before eventually running unsupervised?",
+ "What's a low-risk task where you'd let AI fail a few times while it learns your preferences?",
+ "How do you graduate from 'AI assistant' to 'AI that just handles it'?",
+
+ // About the changing role of engineers
+ "If AI handles the routine work, what do your best engineers spend their time on instead?",
+ "What expertise becomes more valuable when execution gets automated?",
+ "What's the difference between managing AI and managing the systems AI manages?",
+ "When AI can write code faster than you can review it, what changes about your job?",
+
+ // About institutional knowledge
+ "What does your team know that isn't written down anywhere but should be taught to AI?",
+ "What context do new engineers take months to absorb that AI could learn from your tools?",
+ "If AI could learn from how your best people work, what patterns would you want it to pick up?",
+ "What tribal knowledge would you encode into automation if you could?",
+
+ // About the end state
+ "What would 'self-driving software' look like for your team?",
+ "What's the most ambitious workflow you'd automate if reliability wasn't a concern?",
+ "If you could design your toolchain from scratch for AI-first automation, what would be different?",
+ "What would it take for AI to handle your on-call rotation?",
+ ];
+
+ // Single tool questions
+ const toolQuestions: Record = {
+ 'linear': {
+ question: 'What context does AI need to triage issues as well as your best engineer?',
+ option1: 'Codebase knowledge: which files matter, who owns what, what broke recently.',
+ option2: 'Business context: customer impact, roadmap priorities, team capacity.'
+ },
+ 'launchdarkly': {
+ question: 'What signal should trigger an automatic feature flag rollback?',
+ option1: 'Error rate thresholds tied to the specific flag. Hard numbers, fast action.',
+ option2: 'Anomaly detection across metrics. Catch problems that don\'t fit predefined rules.'
+ },
+ 'snyk': {
+ question: 'What makes some security vulnerabilities safe for AI to auto-patch?',
+ option1: 'Clear upgrade path with no breaking changes. Dependency bumps, not code rewrites.',
+ option2: 'Comprehensive test coverage on the affected code. Let tests prove the fix.'
+ },
+ 'notion': {
+ question: 'How do you keep documentation from going stale as code evolves?',
+ option1: 'Automate it. Docs should update when code changes.',
+ option2: 'Make it easy. Reduce friction so humans actually update docs.'
+ },
+ 'continue': {
+ question: 'If AI made writing code faster but teams are drowning in PRs, where\'s the real bottleneck?',
+ option1: 'Downstream. Automate reviewing, testing, merging, and deploying—the workflows around code.',
+ option2: 'Upstream. Slow down code generation. Too much AI code is flooding the pipeline.'
+ },
+ 'devin': {
+ question: 'What kind of issues can async AI agents handle without back-and-forth?',
+ option1: 'Well-specified bugs with clear repro steps and expected behavior.',
+ option2: 'Refactoring tasks with explicit patterns: "rename X to Y everywhere."'
+ },
+ 'jules': {
+ question: 'When AI proactively suggests improvements, how do you avoid noise?',
+ option1: 'Confidence thresholds. Only surface suggestions AI is highly certain about.',
+ option2: 'Batching. Collect suggestions and review them weekly, not as interrupts.'
+ },
+ 'sentry': {
+ question: 'What error patterns are safe for AI to auto-investigate and draft fixes for?',
+ option1: 'Regressions. Code that worked before has a clear "good state" to restore.',
+ option2: 'High-frequency errors. Patterns with many examples give AI more signal.'
+ },
+ 'datadog': {
+ question: 'What makes it hard to correlate metrics with root causes automatically?',
+ option1: 'Too many signals. AI needs to know which metrics actually matter for each service.',
+ option2: 'Missing context. Metrics show what\'s wrong, not why.'
+ },
+ 'posthog': {
+ question: 'What data would let AI generate useful experiment hypotheses?',
+ option1: 'Funnel drop-offs with session recordings. See what users struggled with.',
+ option2: 'Segment comparisons. Find what successful users do differently.'
+ },
+ 'vercel': {
+ question: 'What signals indicate a deploy is safe to promote vs. needs rollback?',
+ option1: 'Error rates and latency percentiles. Core vitals that affect users.',
+ option2: 'Business metrics. Conversion rates catch problems error rates miss.'
+ },
+ 'confluent': {
+ question: 'What makes event-driven AI workflows hard to debug?',
+ option1: 'Non-determinism. Same event can trigger different AI responses.',
+ option2: 'Distributed state. Context is spread across services and time.'
+ },
+ 'cognee': {
+ question: 'When does a knowledge graph beat vector search for AI context?',
+ option1: 'Relationship queries. "Who owns the service that calls this API?"',
+ option2: 'Multi-hop reasoning. Following chains of dependencies.'
+ },
+ 'graphene': {
+ question: 'What makes natural language queries over data reliable enough to trust?',
+ option1: 'Semantic layer. Predefined metrics with business logic baked in.',
+ option2: 'Validation. AI shows its work; humans verify before acting.'
+ },
+ 'github': {
+ question: 'What\'s blocking fully automated merge after approval?',
+ option1: 'Coordination. People want to control when changes go out.',
+ option2: 'Confidence. Tests pass, but humans want one last look.'
+ },
+ 'sanity': {
+ question: 'What content tasks are safe for AI to handle autonomously?',
+ option1: 'Structured data: SEO fields, alt text, metadata from templates.',
+ option2: 'Translations with review. AI drafts, humans approve.'
+ },
+ };
+
+ // Default question when no tools selected
+ const defaultQuestion = {
+ question: "What would it look like if your development workflows could drive themselves?",
+ option1: '',
+ option2: ''
+ };
+
+ // Store the current question so it's consistent between display and prompt
+ let currentQuestion = defaultQuestion;
+
+ // Get a random multi-tool question
+ function getRandomQuestion() {
+ const index = Math.floor(Math.random() * multiToolQuestions.length);
+ return multiToolQuestions[index];
+ }
+
+ function getQuestion(selectedTools: string[]) {
+ // No tools selected
+ if (selectedTools.length === 0) {
+ return defaultQuestion;
+ }
+
+ // Single tool: use tool-specific question
+ if (selectedTools.length === 1) {
+ return toolQuestions[selectedTools[0]] || defaultQuestion;
+ }
+
+ // Multiple tools: randomly select a forward-looking question
+ return {
+ question: getRandomQuestion(),
+ option1: '',
+ option2: ''
+ };
+ }
+
+ function updateQuestion() {
+ const selectedTools = Array.from(document.querySelectorAll('.tool-btn.selected'))
+ .map(btn => (btn as HTMLElement).dataset.tool)
+ .filter(Boolean) as string[];
+
+ // Update and store the current question
+ currentQuestion = getQuestion(selectedTools);
+ const questionText = document.getElementById('questionText');
+ if (questionText) {
+ questionText.textContent = currentQuestion.question;
+ }
+ }
+
+ document.querySelectorAll('.tool-btn').forEach(btn => {
+ btn.addEventListener('click', () => {
+ btn.classList.toggle('selected');
+ const isSelected = btn.classList.contains('selected');
+ btn.setAttribute('aria-pressed', isSelected.toString());
+ updateQuestion();
+ });
+ });
+
+ function buildPrompt(selectedTools: string[]) {
+ // Use the stored currentQuestion to ensure consistency with displayed question
+ const q = currentQuestion;
+
+ let prompt = `# Continuous AI January Dinner
+
+
+## Context
+
+I'm attending the **Continuous AI January Dinner** in San Francisco.
+
+Continuous AI is about automating the workflows around code, not just the code itself. The philosophy is "AI is Glue" — LLMs bond together varying surfaces: human language, CLIs, APIs, webhooks, databases.
+
+**Learn more:**
+
+- [Continuous AI](https://www.continuousai.com)
+
+- [AI is Glue](https://blog.continue.dev/ai-is-glue)`;
+
+ if (selectedTools.length > 0) {
+ prompt += `
+
+
+## Tools I Use
+`;
+ selectedTools.forEach(key => {
+ const p = partners[key];
+ if (p) prompt += `
+- **${p.name}** (${p.role}) — ${p.desc}
+`;
+ });
+ }
+
+ prompt += `
+
+---
+
+
+## Dinner Question
+
+> ${q.question}
+
+
+---
+
+
+## Your Task
+
+What's your take? Search the web for recent developments if helpful. I'll bring your answer to dinner.`;
+
+ return prompt;
+ }
+
+ const aiUrls: Record = {
+ claude: 'https://claude.ai/new?q=',
+ openai: 'https://chat.openai.com/?q=',
+ gemini: 'https://www.google.com/search?udm=50&q='
+ };
+
+ const copyBtn = document.querySelector('.ai-btn.copy-btn');
+ const copyIcon = ``;
+ const checkIcon = ``;
+
+ document.querySelectorAll('.ai-btn').forEach(btn => {
+ btn.addEventListener('click', (e) => {
+ e.preventDefault();
+ const ai = (btn as HTMLElement).dataset.ai;
+ const selectedTools = Array.from(document.querySelectorAll('.tool-btn.selected'))
+ .map(b => (b as HTMLElement).dataset.tool)
+ .filter(Boolean) as string[];
+ const prompt = buildPrompt(selectedTools);
+
+ if (ai === 'copy') {
+ navigator.clipboard.writeText(prompt).then(() => {
+ if (copyBtn) {
+ copyBtn.innerHTML = checkIcon;
+ copyBtn.classList.add('copied');
+
+ setTimeout(() => {
+ copyBtn.innerHTML = copyIcon;
+ copyBtn.classList.remove('copied');
+ }, 2000);
+ }
+ });
+ } else if (ai && aiUrls[ai]) {
+ window.open(aiUrls[ai] + encodeURIComponent(prompt), '_blank');
+ }
+ });
+ });
+
+ updateQuestion();
+ }, []);
+
+ return (
+ <>
+
+
+
+
+
You're Invited
+
Continuous AI January Dinner
+
San Francisco · January 2026
+
+
+
+
Which tools do you use?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
A question to consider
+
+
In 5 years, will AI agents be making more business decisions than humans?
+
+
+ {/* Header */}
+
+
+ Continuous AI
+
+
+
+ {/* Heartbeat - Full width across bottom, only visible on last section */}
+
+
+
+
+ {/* Navigation Dots - Desktop */}
+
+
+ {/* Navigation Dots - Mobile */}
+
-
+
+ {/* Section 1: The Manifesto */}
+
+
+
+
+ The Manifesto
+
+
+ Continuous AI
+
+
Developers are drowning in AI-generated code. Continuous AI addresses this by automating the workflows around code, not just the code itself. The role of the software engineer is shifting from prompting AI to designing processes that run automatically.