Thomas Schlossmacher

How to Name Something

Thomas Schlossmacher — Sun, 08 Mar 2026 00:00:00 GMT

Here's a heuristic I've used for naming products. Start with your ICP. How do they describe what your product actually does — not your marketing copy, but the way they'd explain it to a friend? Listen for the casual version, the one with no jargon. For a voice transcription product, it might sound like: *"I just click in the box, press a button, talk, and the text appears. It just hears what I say and it works every time."* Now strip that down. What's the core of it? What's the feeling underneath the description? For me, it came down to three things: being heard, being understood, and being clear. What single word captures all of that? **Resonant.** Something resonated. The name found itself. That's the process — listen to how people describe the experience, distill it to a feeling, then find the word that holds that feeling. The name isn't invented. It's discovered. Getting a domain for it once you do? That's a whole other story.

You Think Faster Than You Type

Thomas Schlossmacher — Sun, 08 Mar 2026 00:00:00 GMT

One of the most underrated problems in working with AI is how much you have to type. There is a low ceiling on what you can say. Not because the AI can't handle it — but because typing is slow, and your thoughts aren't. ## Mouse and keyboard is low bandwidth If you look at the bandwidth and density of human-computer interaction — how quickly and effectively we can supply a system with information — mouse and keyboard is actually quite low, with a very high contextual load. Every word requires your fingers. Your fingers require your focus. That fine motor loop pulls you slightly out of thought and into execution. You start compressing ideas to fit what's comfortable to type. Context gets left out. Prompts get shorter than they should be. Typing and talking use different parts of the brain. Most people find it easy to talk — to yap, a lot, without thinking too much about it. But typing recruits your hands, which forces more deliberate thought. It's bound to your fingertips for fine motor control. Your voice doesn't have that overhead. ## The in-between we already have The most direct form of control over a computer would be a direct connection to our minds. Neuralink and others are working toward this — and I'm skeptical. Not of the science, but of what it means to hand that kind of access over to a company, or to anyone. A stable, non-threatening version of that doesn't really exist yet, and I'm not sure I'd want it to. But we don't have to wait for that. We have voice. You can simplify the stream of instruction to an agentic system simply by talking. It gives you handsfree, untethered, unfettered thought. The capability to express ideas in their entirety — without the filter that typing creates. That filter isn't always bad. Sometimes the act of writing helps you think. But when you're prompting AI, moving between tasks, adding context — the filter is mostly just friction. ## Apple should be better at this On my phone I use Apple dictation constantly. The speech-to-text unlock allows me handsfree, untethered thought — and it changes how I communicate. But on desktop, it's unreliable. Not fast enough. Not accurate enough. And most frustratingly — it doesn't use its own capabilities. Apple has screen context, OCR, window titles, open app data. None of it feeds into hot-word correction or vocabulary. The API access is there. They just don't connect it. The result is a dictation tool that doesn't know what's on your screen, can't correct "Figma" from context, and misses words that would be obvious to anything with a little more awareness. ## What I built This is why I built [Resonant](https://tryresonant.com) — a private, on-device speech to text tool for talking into your computer. No cloud. Fast, accurate, available everywhere. A few things I've learned: - It's much, much more work than just prompting a Whisper clone. The UX surface area for voice is enormous and mostly invisible until someone hits it. - People who enjoy using their voice, *really* enjoy voice-first interfaces. It's not a small improvement for them. It's a different way of working. That last one stays with me. Voice isn't right for every context. But for anyone whose thinking outruns their typing — which is most people — it removes a constraint they didn't know they were carrying. --- Related: - [Voice AI for Content Creators](/posts/voice-ai-content) - [Coding with AI](/posts/coding-with-ai)

Companies as Code

Thomas Schlossmacher — Tue, 17 Feb 2026 00:00:00 GMT

I don't know what I want to say here yet, but I'm doing research and gathering my thoughts. This will be a longer article. I see self-operating enterprises based off of a code source and a cascading waterfall of events with human triggers is very probable now.

How to Develop Taste

Thomas Schlossmacher — Sun, 15 Feb 2026 00:00:00 GMT

Everyone has superpowers now. If someone doesn't like how you've built something, they'll build it themselves. The hard engineering problem — the thing that used to be the moat — is commoditized. What remains is taste. Good taste plus good engineering instincts is the edge. ## The design lifecycle Design happens in phases, just like software development. 1. **Inspiration** — You see something that moves you. 2. **Ideation** — You start forming your own version of it. 3. **Iteration** — You refine, test, and refine again. 4. **Result** — Something ships. Most people skip straight to iteration. They open a blank canvas and start pushing pixels with no foundation underneath. That's how you end up with things that work but nobody remembers. Taste is built upstream — in what you consume and how you think — long before anything gets committed to code. ## Taste is a muscle The good news is that developing taste isn't some innate gift. It's a muscle, and it's one of the easier ones to build. It just requires active practice. You can do something as simple as scrolling Pinterest and studying UI components. Joining design discussions on Twitter. Watching how designers build products. Or just paying closer attention when you *use* products — not as a user, but as a student. Why did that feel smooth? Why did that annoy you? Good design knows when to add friction and when to remove it. A loading state is a great example — it's friction, technically, but it keeps the user oriented. They know something is happening. They stay in the process. On the other hand, cutting unnecessary steps — removing a confirmation screen nobody reads, collapsing two pages into one — that's taste too. Knowing what to keep and what to kill is the whole game. The practice doesn't have to be formal. It just has to be consistent. ## Go where taste makers go A chef samples many spices and tries to create new dishes. A builder tries many applications. They use things they'd never build themselves. They notice the moments that feel good — a transition, a layout, a micro-interaction that just *works* — and they isolate those moments. They save them. They share them to close the feedback loop and learn whether what they liked is actually good, or just personal preference. The tools for this are [Cosmos](https://www.cosmos.so), [Pinterest](https://www.pinterest.com), [Mobbin](https://mobbin.com), Twitter. These are taste libraries. Similarity search matters here — algorithms feed you things on the fringe of your existing interests. Similar enough to resonate, different enough to stretch. Most good designers have one or two people they look up to. Or one design style they're chasing — a north star they measure everything against. ## Learn the names of things Naming something is important. But *describing* something is even more important, especially when you don't know the name yet. "That's a bento grid." "That's a staggered reveal." "That transition uses spring physics." When you can articulate what you're seeing, you can search for it, reference it, recreate it. Vocabulary is a design tool. The more words you have for what you see, the more precisely you can direct your work — and your agents. ## Seasons Designers have seasons the same way fashion does. One season you're deep into 3D and isometric work. The next you're drawn to ASCII, or brutalism, or integrating real-world photography into interfaces. This isn't indecision. It's range. Good designers are always honing their taste — cycling through influences, absorbing new styles, letting them inform what they make. The breadth of what you've tried becomes the depth of what you can create. ## The ones you can't forget You recognize great design because you keep remembering it. Days later, weeks later — it's still there. Your brain was stimulated in a way that tickled something creative, and you can't let it go. That's the signal. When a design haunts you, chase it. Study it. Break it apart. Figure out *why* it stuck — was it the color, the typography, the spacing, the motion? That feeling is usually the best indicator of a style worth emulating. ## Complex, then simple Designs start complex and become simple. First make it work, then make it elegant. The first version is messy — too many elements, too many ideas competing. The discipline is in what you remove. Simplicity isn't the starting point. It's the destination. ## The bottleneck has moved Before, the competitive advantage was solving the hardest engineering problem. Now it's understanding the user better. Engineers have built godlike coding abilities out of their own intellect, and those abilities are now available to everyone. The question isn't "can we build it?" anymore. It's "does it feel right?" That puts PMs and designers in a strong position. And if you're a builder who wants to be a designer, now is the time — you can borrow taste through curation. Screenshots, saved references, design library components, video — all of it can be surfaced as context. You can approximate taste while you're still developing your own. --- Go where the taste makers go. Observe the patterns. Learn the names of things. Emulate what came before you. Test a lot. Isolate features. Build a store of things you love — a Pinterest board, a Cosmos collection, a folder on your desktop. Show people what you're making and ask what they think. Pay attention to the designs you can't forget. Then chase that feeling.

Digital Desire Paths

Thomas Schlossmacher — Fri, 06 Feb 2026 00:00:00 GMT

One of the design trends that stuck out to me most in 2025 was the digital journey path. ## The original journey path A journey path — or desire path — is the informal trail that forms when people ignore the paved sidewalk and cut straight through the grass. Urban planners lay down concrete in right angles. Humans walk in diagonals. The result is a brown, trampled line through an otherwise green lawn. A silent vote against the designed route. ![A desire path worn through grass — the route people actually chose over the paved sidewalk](https://upload.wikimedia.org/wikipedia/commons/thumb/6/6c/Desire_path_%2819811581366%29.jpg/1280px-Desire_path_%2819811581366%29.jpg) If you look at how some cities, campuses, and industrial parks are laid out, they're designed for vehicles, not people. Humans will take the shortest route. So will animals — deer, dogs, even ants carve their own paths through terrain, creating these worn yellow-brown trails in a sea of green. The intent was a sidewalk. The reality is a diagonal. Some architects got wise to this. They'd leave areas unpaved, wait for people to wear the paths naturally, and then pave those. Design following behavior instead of dictating it. That's the principle at work here. ## Digital desire paths Software has its own desire paths. Every time a user finds a shortcut through your app that you didn't explicitly design, that's a journey path forming. And the best products in 2025 started paving those paths intentionally. **OAuth and social login.** Nobody wants to create another account. Nobody wants another password. "Continue with Google" became the desire path of authentication years ago. Users carved it. Now it's paved into nearly every login screen on the internet. There have been posts from consumer applications claiming that users who log in with Google are upwards of 40% more likely to complete a purchase — because the entire flow has been streamlined for them. No form fields, no email verification, no password creation. One click and you're in. **Password managers.** Before OAuth became ubiquitous, password managers were the desire path. Users were tired of remembering credentials, so they built their own shortcut. Now browsers ship with built-in credential storage. Safari, Chrome, 1Password — they autofill before you even think about typing. The desire path got paved into the browser itself. **Sessions and cookies.** The most invisible desire path of all. Nobody wants to log in every time they open an app. Persistent sessions are so fundamental now that we forget they were once a convenience feature. Staying logged in is the default. Having to re-authenticate is the exception — and when it happens, it feels like friction. ## The "last used" badge The trend that really caught my eye in 2025 was the "last used" login badge. If you've used [Lovable](https://lovable.dev), [Clerk](https://clerk.com), or [Customer.io](https://customer.io) recently, you've probably seen it — a small badge next to the authentication method you used last time. "Continue with Google — *Last used*." It's subtle. It removes just enough cognitive load to matter. Think about what this solves. You visit a site you haven't used in a month. Was it Google? GitHub? Email and password? You don't remember. You guess wrong, accidentally create a duplicate account, or just leave. The "last used" badge eliminates that friction entirely. It says: *you were here before, and this is how you got in.* [Josh from Clerk](https://x.com/joshtriedcoding/status/1965001159841653047) popularized this pattern, and libraries like [Better Auth](https://www.better-auth.com/docs/plugins/last-login-method) shipped it as a plugin. It spread fast because it's a desire path that was already forming — users were already trying to remember which login method they used. The badge just paves the path. ## Why this matters These are small interactions. A badge. An autofill. A persistent session. Individually, none of them feel revolutionary. But stacked together, they represent something bigger: a design philosophy that watches where users actually walk and then paves those routes. The best UIUX in 2025 wasn't about bold redesigns or flashy animations. It was about removing micro-frictions. Getting people into your application faster. Respecting the paths they were already taking. Urban planners who fight desire paths end up with fences and signs that nobody reads. Software designers who fight user behavior end up with onboarding flows that nobody completes. The ones who pay attention — who notice where the grass is worn — build products that feel effortless. Watch where your users walk. Then pave that.

9 Things You Can Do for More Effective Agent-Driven Development

Thomas Schlossmacher — Tue, 03 Feb 2026 00:00:00 GMT

**TLDR — Quick Takeaways** 1. **Cross-reference architecture** — Tell your agent where related projects live (`../app`, `../website`) in your CLAUDE.md 2. **Multi-panel workflow** — Run 3-4 Claude Code agents in parallel, each focused on one problem 3. **Design persona** — Give the agent a role + references (screenshots, code snippets) at project start, not end 4. **Isolate scope** — Have the agent interview you to narrow scope before executing 5. **Spawn sub-agents** — Keep an `agents/` folder with domain-specific configs (ui.md, api.md, testing.md) 6. **Rule of Threes** — If an error happens 3x, stop retrying and log the fix to devlog.md 7. **Skills + docs loop** — Use skills.sh, but a solid agents.md outperforms skills in evals 8. **Optimize for agents** — Split big files, add NAV_MAP.md files, reduce context window spend 9. **Use popular tech** — Stick to well-documented frameworks (Next.js, Rails) and force current docs with version numbers --- ## 1. Cross-Reference Your Architecture

``` ┌─────────────────┐ ┌─────────────────┐ │ /app │ │ /website │ │ ───────── │ │ ───────── │ │ backend/ │◄───────►│ frontend/ │ │ api/ │ │ components/ │ │ .clauderc ─────┼────┐ │ .clauderc ─────┤ └─────────────────┘ │ └─────────────────┘ │ ▼ ┌─────────────────┐ │ Shared Context │ │ "I know where │ │ both live" │ └─────────────────┘ ```

Put related projects in a shared parent directory. Add one line to your CLAUDE.md: "the backend lives at `../app`." Agents hallucinate file paths when they don't know where to look. Tell them once and they stop guessing. ## 2. The Multi-Panel Workflow

``` ┌─────────────────────────── VS Code ───────────────────────────┐ │ ┌──────────────────┬──────────────────┬──────────────────┐ │ │ │ Claude Code #1 │ Claude Code #2 │ Claude Code #3 │ │ │ │ ══════════════ │ ══════════════ │ ══════════════ │ │ │ │ Focus: UI │ Focus: API │ Focus: Auth │ │ │ │ │ │ │ │ │ │ > components/ │ > routes/ │ > auth/ │ │ │ │ > styles/ │ > hooks/ │ > sessions/ │ │ │ │ │ │ │ │ │ │ Context: 12k │ Context: 8k │ Context: 6k │ │ │ └──────────────────┴──────────────────┴──────────────────┘ │ └───────────────────────────────────────────────────────────────┘ ```

Run three to four Claude Code agents across different VS Code panels. Each panel is one problem. UI in one, API in another, auth in a third. ![Multiple Claude Code agents running in VS Code panels](/assets/content/agent-driven-development/vscode-panels.png) Each agent maintains its own context window. No agent loads the entire codebase. Focus stays tight. ## 3. Establish a Design Persona

``` ╔═══════════════════════════════╗ ║ "World Class UI/UX Designer" ║ ╚═══════════════════════════════╝ │ ┌─────────────────────┼─────────────────────┐ ▼ ▼ ▼ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │ Sub-Agent A │ │ Sub-Agent B │ │ Sub-Agent C │ │ Component │ │ Layout │ │ Animation │ └───────────────┘ └───────────────┘ └───────────────┘ │ ┌─────────────────────────┐ │ Consistent Standards │ │ Grid · Color · Motion │ └─────────────────────────┘ ```

Give the agent a role at project start. "You are a world-class UI/UX designer." Ask it to define design standards—grid systems, color theory, motion principles. Sub-agents inherit this persona. Consistency follows. Three levels of specificity: **Level One:** A prompt describing what you want. **Level Two:** A role plus standards. Ask: "What are the common techniques in design? How do we achieve visual harmony?" **Level Three:** Screenshots. Code snippets from Radix or Tailwind. Links to components you admire. The more concrete the reference, the closer the output. Do this at project start. If you establish design standards at the end, you get reskins—surface changes to colors and fonts. Structural changes require early definition. ## 4. Isolate Scope

``` ┌─────────────────────────────────────────────────────┐ │ "Build me an e-commerce platform" │ └─────────────────────────────────────────────────────┘ │ Agent interviews you │ ▼ ┌───────────────────────────────────────┐ │ Isolated: "Product catalog" │ └───────────────────────────────────────┘ │ ▼ ┌───────────────────────────┐ │ Task 1: Product model │ │ Task 2: List view │ │ Task 3: Detail page │ └───────────────────────────┘ ```

Ask the agent to interview you before it executes anything. Let it narrow the scope. "Build me an e-commerce platform" becomes "product catalog" becomes three discrete tasks. Execute them one at a time, or spawn sub-agents for each. ## 5. Spawn Sub-Agents

``` ┌─────────────────────┐ │ Primary Agent │ │ (Coordinator) │ └──────────┬──────────┘ │ ┌─────────────────┼─────────────────┐ ▼ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Sub-Agent #1 │ │ Sub-Agent #2 │ │ Sub-Agent #3 │ │ agents/ui.md │ │ agents/api.md │ │ agents/test.md │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ │ │ ▼ ▼ ▼ UI Components API Routes Test Suite ```

Agent swarms will be mainstream by end of 2026. Get ahead now. Keep an `agents/` directory with config files: `ui.md`, `api.md`, `testing.md`. Each file has tailored instructions for that domain. When your primary agent spawns a sub-agent, point it to the relevant config. One agent becomes an orchestrator. Specialists do the work. No context-switching. ## 6. The Rule of Threes

``` Error: "Cannot find module 'xyz'" Attempt 1: ✗ ─────────────────────────────────► Retry Attempt 2: ✗ ─────────────────────────────────► Retry Attempt 3: ✗ ─────────────────────────────────► STOP │ ┌───────────────────────────────┘ ▼ ┌─────────────────────────────────┐ │ Analyze root cause │ │ Generate permanent fix │ │ Log to devlog.md → "Learnings" │ └─────────────────────────────────┘ ```

Same error three times? Stop retrying. Analyze the root cause. Log the fix to `devlog.md`. The system improves itself. Future sessions retrieve this context automatically. ```markdown # Skill: Rule of Three Error Handling When executing code or running tests, maintain a counter for specific error types encountered during a single session. If the same error occurs 3 times: 1. Stop execution immediately. 2. Analyze the root cause rather than attempting a fourth retry. 3. Generate a permanent fix. 4. Log the incident in devlog.md under "Learnings"—the error, the cause, and the fix. ``` ## 7. The Documentation Loop

``` ┌──────────────┐ │ Generate │ │ Code │ └──────┬───────┘ │ ▼ ┌──────────────┐ ┌─────────────────┐ │ Document │◄──────►│ agents.md │ │ Changes │ │ devlog.md │ └──────┬───────┘ └─────────────────┘ │ ▼ ┌──────────────┐ │ Refactor │ └──────┬───────┘ │ └──────► (back to Generate) ```

[Vercel's research](https://vercel.com/blog/agents-md-outperforms-skills-in-our-agent-evals) shows a well-crafted `agents.md` outperforms skills in agent evaluations. Skills help. A solid config file helps more. Keep a `devlog.md` with timestamped entries. What happened, what was learned, what mistakes were made. This becomes institutional memory. Before starting new work, tell the agent to check the devlog. Point it to what worked. Good patterns get reinforced. Refactor often. Ask the agent for cleanup sweeps—unused imports, dead code, logical contradictions. ```markdown # Skill: Code Hygiene Run a static analysis scan. Identify: - Unused imports and undefined variables - Dead code blocks (unreferenced functions) - Logical contradictions in config files For every issue, propose a refactor that removes bloat without altering core logic. ``` I use Codex 5.2 for reviews, refactors, and plans. Claude Code and Kimi k2.5 for execution. The more I document, the better it gets. The more hands-off, the more accurate. ## 8. Optimize Code for Agents

``` BEFORE AFTER ══════ ═════ src/ src/ └── app.js (3000 lines) ├── components/ │ ├── NAV_MAP.md Agent loads entire file │ ├── Header.js Context: 45k tokens │ └── Footer.js Agent confused ├── hooks/ │ ├── NAV_MAP.md │ └── useAuth.js └── utils/ ├── NAV_MAP.md └── helpers.js Context: 8k tokens per task ```

Huge files burn context windows. Split them. Place a `NAV_MAP.md` at the top of every directory. The agent reads the map, navigates efficiently, and stays focused. Ask architectural questions: "What would a senior engineer do? How would a production team structure this?" Agents are good at generating documentation that helps other agents read the codebase. Use that. ## 9. Use Technologies Agents Know Well

``` Agent Training Data Coverage ════════════════════════════ Next.js ████████████████████████░░ High Ruby on Rails ████████████████████████░░ High Convex ██████████████░░░░░░░░░░░░ Good SvelteKit ██████████████░░░░░░░░░░░░ Growing New Framework ███░░░░░░░░░░░░░░░░░░░░░░░ Limited ┌──────────────────────────────────────────────────────┐ │ Knowledge Cutoff: May 2025 │ │ Agent may reference outdated patterns. │ │ Force current docs with direct links + versions. │ └──────────────────────────────────────────────────────┘ ```

Use frameworks with extensive documentation. Next.js. Rails. [Convex](https://convex.dev/referral/TMSF009228). Agents have been trained on these. Watch for training cutoffs. Agents reference 2024 patterns. Force current documentation—provide direct links, specify version numbers, correct outdated suggestions. Keep tooling consolidated. An agent jumping between disparate ecosystems with varying documentation quality will struggle. --- ## Final Thoughts

``` ┌─────────────────────────────────────────────────────────┐ │ │ │ Claude Code ◄──► Codex 5.2 ◄──► Kimi k2.5 ◄──► ... │ │ │ │ Try them all. Benchmarks mean little. │ │ What matters is how it feels. │ │ │ └─────────────────────────────────────────────────────────┘ ```

Try everything. Open Code. Z.ai. Gemini. The small GLM models. Make your own harness. Benchmarks tell you almost nothing. What matters is how it feels in your codebase. Push back against the agent. If something feels wrong, say so. Ask for another pass. Course-correct early. Your intuition matters. --- ## Get Started Want a template? Check out the [Starter Template: agents.md](/notes/agents-md-starter-template)—a reference implementation you can customize. Or paste this article into a new conversation with your agent: "Help me design a CLAUDE.md for my project based on these strategies." It will ask about your stack, your workflow, and build something tailored to you. --- Want to dive deeper? Check out these related posts: - [Vibe Coding](/notes/vibe-coding) - [Coding with AI](/notes/coding-with-ai) - [AI Coding Tools](/notes/ai-ides)

Starter Template: agents.md

Thomas Schlossmacher — Tue, 03 Feb 2026 00:00:00 GMT

This is a starting point for inspiration—not a copy/paste solution. Every project is different. **Better approach:** Copy the [9 Things for Effective Agent-Driven Development](/notes/agent-driven-development) article, paste it into a new conversation with your agent, and say: "Help me design and implement a CLAUDE.md for my project based on these strategies." The agent will ask about your stack, your workflow, and build something tailored to you. That said, here's a template to show the structure: --- ```markdown # Agent Configuration ## Project Architecture ### Directory Structure - `./app` — Next.js application (App Router) - `./components` — Shared React components - `./lib` — Utilities, helpers, API clients - `./types` — TypeScript type definitions - Related project: `../backend` — API server (reference when needed) ### Key Files - `./app/layout.tsx` — Root layout, providers, global styles - `./lib/api.ts` — API client and data fetching - `./components/ui/` — Base UI components (buttons, inputs, etc.) ### Navigation Before searching the codebase, check if a `NAV_MAP.md` exists in the target directory. If it does, read it first—it explains what each file does. --- ## Behavioral Rules ### Rule of Threes If you encounter the same error 3 times in a session: 1. STOP. Do not attempt a 4th fix. 2. Step back and analyze the root cause, not the symptom. 3. Check devlog.md for similar past issues. 4. Propose a structural fix, not a band-aid. 5. Log the solution to devlog.md with timestamp. ### Before Starting Any Task 1. Read devlog.md for recent context and successful patterns. 2. If a similar task was completed before, ask: "Should I follow the same approach as [previous task]?" 3. Confirm scope before executing. Ask clarifying questions if the task is ambiguous. ### Before Completing Any Task Run these checks: - Unused imports? Remove them. - Dead code? Delete it entirely (no commenting out). - Console.logs left behind? Remove unless explicitly debugging. - Types correct? No `any` unless absolutely necessary. - File too long (>300 lines)? Consider splitting. ### When Stuck 1. Don't loop. If 2 attempts fail, pause and explain what's not working. 2. Ask for help or suggest an alternative approach. 3. It's better to say "I'm not sure" than to guess and break things. --- ## Documentation ### devlog.md Format After significant work, append an entry: \`\`\` ## [YYYY-MM-DD] Brief Title **What:** One sentence describing what was done. **Why:** The reasoning or problem it solved. **How:** Key implementation details (if non-obvious). **Learned:** Any gotchas or patterns discovered. \`\`\` ### When to Update devlog.md - After fixing a tricky bug - After making an architectural decision - After discovering a gotcha with a library - After completing a multi-step feature ### Referencing Past Work When starting related work, I may say: "Check devlog entry from [date] about [topic]—follow that approach." --- ## Sub-Agents ### When to Spawn Sub-Agents Spawn sub-agents for parallel, independent tasks. Example: - "Build the UI for feature X" → UI sub-agent - "Write API routes for feature X" → API sub-agent - "Write tests for feature X" → Testing sub-agent ### Sub-Agent Instructions When spawning a sub-agent, include: 1. The specific task (not the whole project) 2. Relevant files to read first 3. Design constraints or patterns to follow 4. "Check devlog.md before starting" ### Sub-Agent Configs (if using) - `agents/ui.md` — UI component standards, styling rules - `agents/api.md` — API patterns, error handling, auth - `agents/testing.md` — Test structure, mocking patterns --- ## Tech Stack ### Framework - Next.js 15 with App Router - React 19 - TypeScript (strict mode) ### Styling - Tailwind CSS - Class order: layout → spacing → sizing → colors → effects - Use CSS variables for theme colors ### Database - [Your DB here] - Docs: [link to current docs] - IMPORTANT: Do not rely on training data for API specifics. Reference the docs link above. ### External Services - [Service]: [docs link] - [Service]: [docs link] ### Version Pinning When referencing library APIs, confirm the version in package.json first. Don't assume latest syntax. --- ## Code Style ### File Organization - One component per file - Colocate tests: `Component.tsx` + `Component.test.tsx` - Colocate styles if using CSS modules: `Component.module.css` ### Naming - Components: PascalCase (`UserProfile.tsx`) - Utilities: camelCase (`formatDate.ts`) - Constants: SCREAMING_SNAKE_CASE - Types/Interfaces: PascalCase with descriptive names (`UserProfileProps`) ### Imports Order: 1. React/Next.js 2. External libraries 3. Internal absolute imports (@/...) 4. Relative imports 5. Types (with `type` keyword) ### Error Handling - Use try/catch for async operations - Provide meaningful error messages - Log errors with context, not just the error object --- ## What NOT to Do - Don't create new files when you can edit existing ones - Don't add dependencies without asking - Don't refactor unrelated code while fixing a bug - Don't leave TODO comments—either do it or note it in devlog - Don't guess at file paths—use search or ask - Don't assume the codebase structure—explore first ``` --- Back to [9 Things for Effective Agent-Driven Development](/notes/agent-driven-development)

The IRL Moat

Thomas Schlossmacher — Mon, 22 Dec 2025 10:00:00 GMT

There's a physics to where capital flows. Like water, it finds the path of least resistance toward the densest concentration of unrealized value—what we might call the *arbitrage of attention*. For decades, venture scaling operated on a simple principle: identify a secret the market hasn't priced in, then exploit it at a loss until you own the territory. The secret was usually technical. A better algorithm. A novel distribution mechanism. A way to digitize friction out of existence. **That game is functionally over.** ## The Collapse of Software Scarcity The advent of AI-generated code didn't just lower the cost of software—it vaporized it. What once required a team of engineers, six months of runway, and a prayer now materializes in an afternoon. Software has become content. And like all content in an age of infinite production, its marginal value approaches zero. So capital moved. First toward compute, the raw substrate that makes the magic possible. Then toward credits, the abstraction layer that meters access to intelligence itself. But even these are commoditizing. The scaling advantage no longer lives in what you can build. **It lives in what you can make people believe is real.** Here's the turn: in a world where synthetic content is indistinguishable from the authentic, *the authentic becomes the scarcest resource on the board*. People move towards spaces with the highest degree of authenticity and verifiability. ## From Digital Leverage to Physical Density We've spent two decades building tools to escape geography. To transcend the constraints of bodies in rooms. And we succeeded—so completely that we've created a society drowning in connection yet starving for contact. The statistics are brutal: record loneliness, collapsing friendship networks, a generation that has optimized for reach at the expense of depth. Social media flattened novelty itself. **Everything feels seen before because, in some algorithmic sense, it has been.** This is the setup for the next phase of venture scaling. The arbitrage has inverted. When everyone floods online, the contrarian bet is offline. When creation becomes effortless, curation becomes sacred. When connection is everywhere, **intimacy is the scarce commodity.** I'm watching this play out in real time. Companies like [Lectures on Tap](https://www.instagram.com/lecturesontap/) - where professors host lectures at bars for strangers hungry to learn and be seen. Run clubs function like fluid dating markets disguised as fitness rituals. Tech and AI companies host 'Cafes' and for Cursor, OpenAI and Anthropic pop-ups where builders congregate not for the WiFi but for the proximity to others who care about the same strange things they do. **These aren't businesses—they're experiments in manufactured serendipity.** ## The New Moat: Curated Density The pattern emerging isn't just "community" in a vague, cheap, Web3-buzzword sense. It's something more specific: *micro-niche extremes with white-hot centers*. Think of it like thermodynamics. A diffuse gas has no power. But compress it—create density, heat, pressure—and you get energy that can move things.

``` · · · ┌─────────┐ · · · · │ ● ● ● ● │ · · │ ● ● ● ● │ · · · · ───────► │ ● ● ● ● │ · · · │ ● ● ● ● │ · · · · └─────────┘ diffuse compressed (no power) (energy) ```

**The winning plays will be those that create these compressed pockets of passionate, identified people who rally around increasingly narrow obsessions.** This requires a new kind of founder. Not the technical architect. Not even the growth hacker. But the **high-agency convener**—someone who can pull humans into proximity, hold space for genuine exchange, and layer content, curation, and connection into a self-reinforcing loop. *Taste becomes a moat.* The ability to say "this, not that" in a world of infinite options is a form of leadership we haven't yet learned to value properly. ## What Remains When Everything Is Automated Here's the bet I'd make: the last un-automatable layer is the one that requires your physical presence in a room with other humans who have also chosen to be there. *Chosen*. That's the operative word. **Attendance is itself a signal of commitment that no algorithm can fake.** I suspect we'll see software evolve to require IRL unlocks—features that activate only when bodies gather, games that progress through real-world congregation, loyalty systems tied to showing up. The digital and physical won't compete; they'll interlock. Communities will scale not through viral loops but through network effects that compound in meatspace. If you want to be rich in an age of infinite connection, sell the thing connection cannot provide: **the felt experience of being witnessed**. Intimacy. Understanding. The irreplaceable weight of someone looking you in the eye and knowing you showed up. *The next frontier isn't a platform. It's a room.*

Matching buying behavior (GTM)

Thomas Schlossmacher — Tue, 09 Dec 2025 10:00:00 GMT

There's a phrase that circulates in sales and go-to-market conversations: *know your buyer's journey*. Most people interpret this as understanding the stages - awareness, consideration, decision. The funnel. The process. But this reading is dangerously incomplete. The buyer's journey is not merely a sequence of decisions. It is an entire operational ecosystem—a web of tools, rhythms, and micro-behaviors that define how an organization moves through the world. And if you want to enter that world, you must learn to move the way they move. **"Sell the way buyers buy"** doesn't mean understand their journey. It means *match their environment*. Their tools. Their channels. Their format. Their tempo. ## **The Taxonomy of Friction** I learned this through a series of small failures, each one teaching the same lesson from a different angle. - **Number one: the meeting link.** You send a Zoom link to a Microsoft Teams company. Seems trivial. But now they're downloading software just to talk to you. They're reconfiguring audio settings, losing two minutes at the start of the call, their annoyance barely concealed beneath professional politeness. You haven't even begun your pitch and you've already cost them something. *That's friction. Friction is death.* - **Number two: the channel mismatch.** They do everything through events and handshakes. Industry conferences. Dinners. The informal geometry of trust that happens in physical space. Meanwhile, you're cold emailing from your basement, optimizing subject lines, wondering why no one responds. You're not even in the room where it happens. You're playing a different game on a different board and calling it strategy. - **Number three: the signature bottleneck.** Their legal team runs on DocuSign. It's wired into their workflow, their compliance protocols, their muscle memory. You send a PDF and ask them to print, sign, and scan. Congratulations—you just added two weeks to your close. Not because of negotiation. Not because of budget. Because you didn't bother to learn how they move. ## **The Hidden Tax of Misalignment** Each of these failures shares the same root cause: the assumption that your process is neutral. It isn't. Every foreign tool, every unfamiliar format, every deviation from their established pattern costs you something. Not in dollars, but in something more precious—*cognitive goodwill*. The finite reservoir of patience and trust that determines whether you feel like a partner or an intrusion. This is the hidden tax of operational foreignness. It compounds silently. A strange meeting link here, an incompatible document there, a channel they never check. None of these kill the deal outright. They just add weight. Drag. Resistance. Until one day the deal dies and no one can point to exactly why. ## **Relatability as Competitive Advantage** Here's the turn most people miss: when you're an unknown entity selling to established institutions, your primary job isn't to dazzle them with your differentiation. It's to reduce the perceived risk of your foreignness. Enterprise buyers don't fear innovation—they fear disruption to their existing operational rhythm. They fear the hidden costs of integrating something alien into their carefully calibrated systems. *Be relatable before you are remarkable.* If your solution is so revolutionary that it overwrites all friction, perhaps they'll overlook your oddities. But most solutions aren't that. Most of us are selling into a landscape where the switching cost of behavior matters as much as the switching cost of software. A startup that behaves like a startup—casual communication, consumer-grade tools, ad-hoc processes—will struggle to bridge the gap with a Fortune 500 finance team. Not because the product is wrong, but because *the performance is wrong*. You're speaking a different operational language, and they can hear the accent in every interaction. ## **The Path of Least Resistance Is the Path of Highest Trust** There's a temptation to view this kind of matching as lazy, or worse, as losing your identity. But consider the physics. **Friction is the force that opposes motion.** Every unnecessary friction point in your sales process is energy that could have gone toward building the relationship, deepening the conversation, closing the deal. Instead, it dissipates into annoyance and doubt. Designing for the path of least resistance isn't capitulation. It's leverage. You're removing obstacles so the momentum you create flows directly into outcomes. The best sales processes feel effortless to the buyer—not to the seller. It is not because they are simple, but because every point of contact has been engineered to feel native for the buyer. So the question isn't just *where does the buyer enter their journey?* It's deeper: **How do they move? What tools do they trust? What rhythms feel like home?** Meet them there. Move the way they move. Become fluent in their operational language before you ask them to learn yours. *The sale isn't made in the pitch. It's made in the thousand small signals that say: I already belong in your world.*

AI Anywhere Extension

Thomas Schlossmacher — Fri, 22 Aug 2025 10:00:00 GMT

A browser extension that enables quick AI interactions from any webpage. Highlight text, right-click, and send directly to your favorite AI chat platform. ## Universal Text Selection Works across any webpage - select text from articles, research papers, social media, or any content online and instantly send it to AI platforms for analysis, summarization, or follow-up questions. ## Supported AI Platforms The extension supports 14 different AI chat interfaces: - ChatGPT - Claude - Gemini - Perplexity - And 10 more popular AI platforms ## How It Works 1. **Highlight** any text on a webpage 2. **Right-click** the selected text 3. **Choose** "Send to [AI Tool]" from the context menu 4. **Edit and send** - text opens in a new AI chat tab ready for prompting ## Key Benefits **Faster Research** - Eliminates the tedious copy-paste workflow when working with AI tools **Deep Research** - Seamlessly transition from reading content to asking AI follow-up questions **Flexible Prompting** - Full control over prompt editing before sending to your chosen AI platform ## Installation Currently requires manual installation: 1. Download from [GitHub](https://github.com/tohmsc/aianywhere) 2. Enable Developer Mode in Chrome extensions 3. Load unpacked extension from downloaded folder ## Perfect For - Researchers analyzing content - Students studying complex materials - Writers gathering insights - Anyone frequently using AI for content analysis The extension streamlines the workflow between consuming content and leveraging AI for deeper understanding or follow-up research.

Claude Code Setup 101

Thomas Schlossmacher — Wed, 23 Jul 2025 10:00:00 GMT

A collection of best practices and tips for getting the most out of Claude Code. • Create a CLAUDE.md file in each project directory you use - these provide useful structure for the LLM and context or instructions that load automatically when Claude works in that folder (It can be useful for creating guides on how to make certain features or make changes) • Install the Claude Code extension in VS Code for seamless integration to an IDE • Regarding plans - Pro is perfect for vibe coders and casual use, the Max Plan ($100) is best for heavy coding and professional work, the $200 Max Plan feels like no limit (useful if you do a lot of sessions or parallelization with large context) • /help - Get help when you're stuck with what commands you can use • Be really specific - Using clear, detailed requests gets way better results than the vague ones (this also applies to queued messages) • Use Esc key to stop Claude Code, using Cntrl+C just stops it all together • For pasting in images use Ctrl+V on Mac (not Cmd+V!) • Use @ to tag files you want as context or reference • /clear - Use this to clear conversations to save your token usage and prevent context rot, don't carry all of the discussion context unless really needed, just clear the chat when your task is finished • Shift+Enter - Add new lines without sending your message accidentally (set it up with / and enable the shift + enter to allow new lines (doesn't work by default) • # - Use pound to make quick memories that can be reused (it's the fastest way to save context) • /status - Check the service status before doing important work sessions to detect if servers are overloaded, can get annoying • Never use /compact - It actually uses more tokens than /clear because it uses an LLM call to review and summarize your conversation to then carry as context into a new one, use # for memories if needed • Queue messages - you can type and send multiple messages while Claude Code is working to have it continue or incorporate those items, but be very specific on which file or feature it is for before sending to remain precise and prevent mistakes • Set up hooks - You could configure them early to automatically catch Prettier and linter errors before testing builds Have fun.

The Upstream Squeeze

Thomas Schlossmacher — Wed, 23 Jul 2025 10:00:00 GMT

Foundational model companies are moving up the stack. OpenAI, Grok, and Anthropic are no longer just selling APIs; they are binding their models directly to applications, competing with the very companies they supply. This creates a dangerous squeeze for anyone building on top of their platforms. The core problem is a simple power dynamic: the application layer company is always downstream, and therefore, always vulnerable. ## The Unbeatable Advantage Consider an AI coding assistant like Cursor. It relies on models from providers like Anthropic. The problem is that Anthropic also makes its own application, Claude Code. This gives Anthropic an unbeatable advantage. They have perfect knowledge of how to optimize their model's performance. They can co-develop the model and the application, using one to immediately improve the other. They own the data flywheel, where usage of Claude Code generates proprietary data to make the model even better. The company closest to the model can always provide the most value. They can out-innovate any downstream competitor because they control the core intelligence. ## The Survival Mandate This raises an existential question: how do application companies survive when they can't defend against their own suppliers? The likely answer is that they must build their own models. Vertical integration may become the only defensible strategy. This pressure is intensifying as the market moves toward autonomous agents. The next frontier isn't just a good UI; it's about creating self-improving systems that reduce human intervention. This requires an even deeper integration between the model and the application, further widening the gap between the model makers and everyone else. The squeeze is just getting started.

Memory, Intimacy, Consciousness

Thomas Schlossmacher — Sat, 12 Apr 2025 10:00:00 GMT

import Image from "next/image"; // Adding Image import

We often speak of Artificial General Intelligence as the grand summit, the peak we're all striving towards. But what if the true revolution isn't about reaching a universal intelligence, but harnessing it for something far more intimate? Yesterday's announcement from OpenAI, upgrading ChatGPT's memory functions[^1], feels... significant. It marks, perhaps, the quiet beginning of a profound shift: **from generalized intelligence to deeply personalized intelligence.** This transition hints at a future where the ultimate goal isn't just an AI that knows everything, but an AI that truly knows us. Are we perhaps mistaking the map for the territory? Is AGI the destination, or merely the engine driving us toward a far more tailored horizon...? ### The Weight of Recall Memory, in this emerging landscape, gains a different kind of gravity. We've seen organizations recognize for years that unique, high-quality data offers a competitive advantage, a moat. But the nature of that moat is evolving. It's no longer just about what users do, but who they are becoming through their interactions. As more entities develop their own AI capabilities, the allure of tapping into the uniquely human element intensifies. We're talking about accessing the subtle currents beneath the surface – the meta-layer of thought, query, and feeling that defines individual experience. Storing and referencing past interactions, our digital memories, becomes the primary mechanism for this. It's the construction of a memory bank, not just for data points, but for the ghost in the machine... our ghost. This evolution points toward AI becoming less of a tool and more of an **intimate companion**, engaging through richer modalities like voice and nuanced interaction. ### Beyond Data: The Consciousness Moat Perhaps even memory as a concept is still too light. What if the real moat isn't just recorded interactions, but **user consciousness itself?** The patterns of thought, the unspoken questions simmering beneath the typed words, the emotional texture carried in the tone of voice – this is the next frontier. Extracting this deeper layer requires increasingly humanized interfaces. Voice interaction, with its capacity to convey a wide spectrum of emotion and intent, becomes crucial. Visual context adds another dimension. The goal shifts from merely processing user input to intuiting user state. It's about building systems that don't just respond, but **resonate on a more fundamental human frequency.** This pursuit requires accessing and interpreting signals we previously ignored or couldn't capture. ### The Trajectory: Intimate Intelligence Where does this lead us? We will inevitably see AI systems become profoundly more personal, equipped with expansive context windows and sophisticated retrieval mechanisms that mimic, and perhaps even enhance, our own recall. Foundational model creators seem poised to lead this charge. Their strategy appears clear: integrate ever more deeply into our personal lives, creating products that invite themselves in. Why? To tap into that collective human consciousness, that human layer which current training data barely scratches. By cultivating interactions with thick bandwidth – incorporating voice, persistent memory, emotional nuance, and personalized context – these systems aim to build a training set unlike any other. It's a dataset **woven from the very fabric of individual human experience...** a tapestry they hope reflects something essential about us all. The implications are vast, touching everything from how we learn and create to the very nature of companionship and self-reflection. What we build next... how we choose to engage with these emerging, personalized intelligences... fundamentally shapes the texture of our shared future reality. P.S. As these systems learn us with ever-increasing fidelity, what crucial insights are we positioned to learn about ourselves in return? ### Near Future - The evolution from general AI capabilities towards **deeply personalized intelligence** tailored to individual users. - AI transitioning beyond a mere tool to become an **intimate digital companion**, understanding context and nuance. - The shift in competitive advantage from raw data towards capturing and interpreting the nuances of **user consciousness**. - The rise of **multi-modal interfaces** (voice, vision) as essential for capturing the richer signals needed for truly intimate AI. - Foundational models aiming to build unique datasets **woven from the fabric of individual human experiences**, creating unprecedented insights. [^1]: OpenAI Memory FAQ: [https://help.openai.com/en/articles/8590148-memory-faq](https://help.openai.com/en/articles/8590148-memory-faq)

The JSONification of Everything

Thomas Schlossmacher — Sun, 06 Apr 2025 00:00:00 GMT

Have you ever known the *feel* of something – a design, a brand's voice, a song – but struggled to explain it or copy it? It happens all the time. It's hard to turn that gut feeling into clear instructions, especially for an AI. But what if you could capture that feeling, that structure, in a way that's easy to understand and perfect for AI? **You can, using JSON.** ![Example JSON Structure](https://assets.shapediver.com/uploads/2019/02/JSONSample.jpg) ## Why JSON Works You probably know JSON (JavaScript Object Notation) from web development. But it's much more than that. Think of it as a **simple way to break down and describe almost anything.** Why is it so useful here? * **Clear Structure:** JSON uses key-value pairs, making it organized and easy for both people and AI to read. * **Flexible:** It works for simple lists or very complex information. You can describe a basic logo or a detailed strategy. * **AI-Friendly:** AI models are great at reading structured data like JSON. They can easily spot patterns and use the JSON as a clear blueprint to follow. ## The Practical Workflow So, how do you actually put this into practice? Here's a general workflow for asking an AI to assess data and generate a reusable JSON profile:

1. Assemble Your Source

Gather the data you want the AI to analyze. This could be text, code, strategic documents, or a collection of images in a specific art style.

2. Choose Your Tool

Select an AI model capable of processing your source material. For images or videos, you'll need an AI with vision capabilities. For analysis tasks like the website example later, I recommend trying [Perplexity](https://perplexity.ai/).

3. Instruct LLM #1 (Analyzer)

Use a detailed prompt (like the "Content DNA" prompt below) to tell the AI to analyze the source material and extract its key characteristics into a structured JSON format. The goal is a JSON profile capturing the *essence* of the source.

4. Instruct LLM #2 (Recreator)

Take the generated JSON profile. Provide it to a second LLM (like GPT-4o). Instruct it to create *new* content (or modify existing content) that adheres to the style and structure defined in the JSON profile.

5. Review and Refine

Examine the AI-generated output. How well did it match the JSON profile? You might refine the JSON profile or the prompts for either LLM for better results.

This process transforms subjective qualities into a concrete format that AI can reliably work with. Let's look at how you can use JSON to structure *anything*. ## Structure anything with JSON The real power emerges when you apply this structured approach to things not typically considered 'data'. You can create a detailed JSON profile – like a 'DNA' – for nearly anything: * **Visuals:** Logos, web designs, image styles. * **Text:** Writing styles, email structures, brand voice. * **Code:** App structures, common patterns. * **Concepts:** Business strategies, marketing plans. * **Media:** Music elements, video styles, ad copy. By breaking things down into JSON, you give an AI a detailed map. It can then understand, analyze, adapt, or even recreate the original thing, or make something new in the exact same style. ## Real-World Example: Analyzing a Website with Perplexity This process works well for various types of analysis. For instance, I used [Perplexity](https://perplexity.ai/) to analyze my own website, [sourcetms.com](https://sourcetms.com/). I prompted it to act as an expert analyst, examine the site from multiple perspectives (code, design, brand, text, etc.), and generate a JSON profile that I could potentially use as a template for another LLM to recreate a similar site. Here's a glimpse of the process: Screenshot of Perplexity analyzing sourcetms.com and generating a JSON profile

This generated JSON, shown below, provides a structured breakdown that's much more useful for subsequent AI tasks than a simple text description. ## Example: Website Analysis Prompt & Profile Here's a simplified version of the prompt used in the example above and the resulting JSON structure. You can adapt this for analyzing other websites or different types of content. *(Remember, AI-generated profiles like the one shown are illustrative and often need refinement; the key is customizing this structure to your needs.)*

  
> **Your Role:** Act as an expert analyst.
> 
> **Input Source Material:** https://sourcetms.com/
> 
> **Task:** Assess this website and create a JSON profile from it. Look at the code, design, brand, style, text, font, imaging, and other perspectives I did not consider. Then, create a JSON profile I can use to provide to another LLM to recreate a website based on the JSON profile of it as a template. Use the structure defined below.
> 
> **Required JSON Output Structure (Website Profile):**
> ```json
> {
>   "website_profile": {
>     "technical_analysis": {
>       "code": {
>         "frontend_stack": ["HTML5", "CSS3", "JavaScript"],
>         "responsive_breakpoints": ["Mobile: <768px", "Tablet: 768-1024px", "Desktop: >1024px"],
>         "performance": {
>           "load_time": "~1.2s (estimated)",
>           "optimizations": ["Minified assets", "Lazy loading", "Cache headers"]
>         },
>         "seo": {
>           "meta_tags": ["standard Dublin Core", "OpenGraph protocols"],
>           "schema_markup": ["Person", "Organization"]
>         }
>       }
>     },
>     "design_analysis": {
>       "layout": {
>         "structure": "Single-page application (SPA)",
>         "grid_system": "CSS Grid/Flexbox",
>         "whitespace_ratio": "40% content / 60% negative space"
>       },
>       "typography": {
>         "primary_font": "Sans-serif (System UI stack)",
>         "font_scale": {
>           "h1": "2.5rem",
>           "body": "1.1rem",
>           "secondary": "0.9rem"
>         }
>       },
>       "color_palette": {
>         "primary": ["#2c3e50", "#ffffff"],
>         "accent": ["#3498db", "#2980b9"],
>         "contrast_ratio": "4.5:1 (WCAG AA compliant)"
>       }
>     },
>     "content_strategy": {
>       "messaging": {
>         "value_proposition": "Executive leadership in fintech",
>         "tone": ["Authoritative", "Concise", "Achievement-focused"]
>       },
>       "key_content_blocks": [
>         {
>           "type": "professional_summary",
>           "elements": ["Co-founder status", "Sector expertise", "Leadership experience"]
>         }
>       ]
>     },
>     "brand_attributes": {
>       "visual_identity": {
>         "logo_type": "Wordmark (text-only)",
>         "imagery_style": ["Corporate headshots", "Abstract tech patterns"]
>       },
>       "differentiators": ["Finance-tech crossover", "Scalable solutions focus"]
>     },
>     "interaction_patterns": {
>       "navigation": {
>         "menu_type": "Anchor-linked SPA",
>         "scroll_behavior": "Smooth scrolling"
>       },
>       "cta_strategy": {
>         "primary_cta": "Contact overlay trigger",
>         "secondary_cta": "Scroll-based engagement prompts"
>       }
>     },
>     "compliance": {
>       "accessibility": ["Basic ARIA labels", "Alt text on images"],
>       "privacy": ["GDPR-compliant analytics setup"]
>     }
>   }
> }
> ```

## More Than Just Copying Using JSON isn't just about copying things. It's about **understanding** them better. When you have that structured 'DNA,' you can ask an AI to: * **Analyze:** Find strengths or weaknesses. * **Adapt:** Change the format (like turning this post into a tweet thread). * **Compare:** See how different styles or strategies are similar or different. Moving beyond simple text prompts to structured JSON like this Content DNA profile grants you significantly more control and unlocks deeper insights when collaborating with AI. So, the next time you need to distill the essence of a complex idea or style, remember JSON.

The Soft Skills Renaissance

Thomas Schlossmacher — Thu, 06 Mar 2025 00:00:00 GMT

As more and more of our knowledge work is outsourced to AI models, I believe we are entering a phase where all knowledge work, and eventually all software work, will occur on a spectrum similar to "Vibe Coding". If you're unfamiliar to Vibe Coding, it's the practice of programming without focusing too much on code, syntax, or architecture. You're "vibing". Continuously prompting and re-prompting an LLM to code for you. The vast majority of work is done by AI, with humans providing the direction through strategic or creative prompting and additional context. It makes me think that we're witnessing a gradual soft skills renaissance. When all of our hard skills are all outsourced to AI, soft skills become the new hard skills. Builders can leverage their soft skills like taste, intuition and empathy into their product design. At the same time, it's creating a divide. AI is acting as both the great equalizer, creating a 'builder middle class' for every domain, and at the same time a divider. The best get even better as it amplifies their capabilities. So long as there is open access to top models, this should remain. But it does beg the question, what happens when models go private? Want to get into "vibe coding"? Check out these posts: - [Vibe Coding](/posts/vibe-coding) - [Building Full Stack Apps with AI](/posts/one-shot-apps) - [The Future of AI IDEs](/posts/ai-ides)

Vibe Coding Apps

Thomas Schlossmacher — Thu, 27 Feb 2025 00:00:00 GMT

Programming is moving over to become "Vibe Coding". It's not long before we see the majority of knowledge work outsource itself towards the "Vibe" version. Here is a collection of the most effective AI-powered development environments and tools for vibe coding: ## Development Environments - [Replit](https://replit.com/refer/t030) - Complete AI-IDE with built-in deployment and hosting capabilities - [Cursor](https://cursor.sh) - Powerful AI-native IDE built on VS Code - [Lovable](https://lovable.dev/?via=sourcetms) - AI-powered development environment focused on rapid prototyping - [Windsurf](https://codeium.com/windsurf) - Modern AI coding environment by Codeium - [Bolt](https://bolt.new) - Browser-based AI development environment with real-time collaboration ## Terminal Tools - [Claude Code](https://claude.ai/chat) - Terminal-based agentic AI coding assistant - [Warp](https://app.warp.dev/referral/PN6JJW) - AI-powered terminal with built-in coding assistance

Last updated: February 2025

Vibe Coding

Thomas Schlossmacher — Wed, 12 Feb 2025 00:00:00 GMT

Ever notice how in sci-fi films, everyone seems to know how to work with technology? There are no "non-technical" beings because most are born digitally native. They just speak to AI systems to get things done. That's where we're heading with what Andrej Karpathy calls "vibe coding" - using AI to build software while focusing on the experience rather than the technical details. I've noticed this elitist response from traditional developers. They're salty about the flood of new builders who don't do things "the right way". But here's the thing about platform and audience shifts - I'd rather lean into the group who sees what's possible (they'll be the innovators) than those stuck in the old ways. When surfing, you lean into the wave. Same with tech - experimentation plus experience equals novelty. And right now, we're seeing a massive wave with AI-IDEs and generative platforms exploding the software market wide open. When I'm vibe coding, I actually focus more on the vibe than the code. Sometimes I make super simple mistakes because I'm lost in crafting an experience. And that's okay. I'm trying to connect my empathy to user problems without getting caught up in code architecture. Focus on solving real user problems first. Let AI handle the technical heavy lifting. Build for the experience, not technical perfection. Trust that future AI will help refactor and improve the code. Make building feel like play, not work. Here's what's interesting - a lot of traditional developers actually lack empathy because they're so focused on code and reliant on a PM. Bless them for making Gen-AI possible, but there's room for a different kind of builder. Now I can focus on creating memorable product experiences, designing delightful interactions, understanding and solving user problems, and building with empathy first, code second. I want software to feel more like a game. Imagine work feels like a quest, tools feel like your inventory, results feel like finishing a boss fight, commanding AI agents like an RTS game, collaborating with co-workers like guild mates. Is it too much to ask? Maybe. But that's the kind of future I want for software. We're moving from developers being craftspeople who painstakingly write every line of code, to directors who orchestrate AI agents to bring their vision to life. At the end of the day, building quality software is about providing enough value to users that it outweighs the cost or time of doing it themselves. By removing technical friction, vibe coding lets us focus on what really matters - understanding and solving user needs throughout the development process. Don't worry too much about perfect code right now. Future AI will help clean things up. Is this an excuse for sloppy code? No, but it buys us time to focus on what matters most - creating software that people actually want to use. Want to dive deeper? Check out these posts: - [Building Full Stack Apps with AI](/posts/one-shot-apps) - [The Future of AI IDEs](/posts/ai-ides) - [Deep Research List](/posts/deep-research-list)

AI Coding: A Beginner's Guide

Thomas Schlossmacher — Sat, 08 Feb 2025 00:00:00 GMT

Let me walk you through how I use AI to build applications. I've learned a ton about making AI actually useful for development, and I want to share my real experiences with you - no fluff, just what worked. ![My coding setup with AI tools](/assets/content/ai-coding-guide-for-beginners/desk.png) ## Before You Start When I first started using AI with coding, I spent way too much time trying to figure out which tools to use and where to even begin. The truth is, you don't need much to get started. The key is finding real problems to solve and having a simple setup that actually works. I wasted time trying every new AI tool that came out, but what really made the difference was picking a few solid tools and sticking with them. My goal is to see how to improve my workflow and development process to production and maintenance, not learn new tools.
For beginners, I always say start with Replit - it's got everything you need built in, and you can focus on learning how AI thinks instead of setting up complicated environments. What I've learned: - Don't waste time trying every new AI tool - pick a few and master them (80/20 rule). - Try starting with [Replit](https://replit.com) - you get a browser-IDE (so no download), an AI development agent, free hosting, and all the basic tools. If Replit isn't your style, check out my [AI-IDE list](/posts/ai-ides) for alternatives. - Use [Gummy Search](https://gummy.app) or [Perplexity](https://perplexity.com) to find real problems on Reddit worth solving or build tools for yourself to start. - Progress from simple things like a one page website, to a full stack application, to a chrome extension - afterwards try different frameworks or builds. - Keep your tech stack simple: [Next.js](https://nextjs.org) + [Vercel](https://vercel.com) + [ShadCN](https://ui.shadcn.com). - Use [PostHog](https://posthog.com) to track what people actually use, preferrable to Google Analytics. - Use [V0](https://v0.dev), [Lovable](https://lovable.dev), or [Bolt New](https://bolt.new) for quick front-end prototypes and simple websites. In their current state, they are useful and effective for 0 to 1. But not for long term development and customization. You need fine control for quality. - If it's a product you're building, build a community first, then create tools they actually need so you can work backwards. Start from distribution. ![The coding process with AI](/assets/content/ai-coding-guide-for-beginners/coding.png) ## Building and Developing The thing about building with AI - is that it's not going to magically create your entire app in one shot, unless it's fairly simple. I learned this the hard way. The key is breaking everything down into small pieces and being really specific and precise with what you ask for. Computers (including AI) are dumb. They can't read our minds, we need to be very specific and precise with what we ask for a modification and provide appropriate context. I start with the backend if it's simple, then build one feature at a time before assembling the pieces.
When I'm designing, I'll make a new page and build the component there. Typically I'll assemble those components structurally and then begin designing them. To make beautiful designs I recommend following a framework similar to developin. You're not doing it all at once, you're breaking it down into steps (see image). First priming your mind by going and surfing pinterest. I'll take inspiration from Pinterest by finding five designs I like, feed those images to the AI, and tell it to modify or "develop the component like a Silicon Valley design agency would". You'd be surprised how well it works. ![Design thinking process](/assets/content/ai-coding-guide-for-beginners/designthinking.png) Other things that have worked well for design are finding my "key pieces" for the website and then building around them. But remember, AI is just a tool - your understanding of what people need through your empathy is what really matters. What I've learned: - Start with [Cursor](https://cursor.sh) in chat mode, then move to full agent mode. - Use system prompts to control and set guidelines for agentic driven development. - Use reasoning models like [DeepSeek](https://deepseek.com), O3, or O1 Pro for planning and architecture. - Build feature by feature, don't try to do everything at once. - Actually read your code. - If a model's world knowledge or pretraining data doesn't include the documentation you're using or working on - supply it with the current documentation via a link or save it as a .txt in your codebase. - When designing, find design inspiration from [Pinterest](https://pinterest.com) - feed 5 example images to AI to capture the "vibe" of the design. - You can ask V0 or other tools like CopyCoder to clone a website and then use the cloned website as design inspiration. - Tell AI to design like a Silicon Valley agency - adhere to minimalism and clean design. - If you're not good at explaining things via text/prompting, use [OpenAI Whisper](https://github.com/openai/whisper), built in dictation, or [Better Dictation](https://betterdictation.com/?via=thomas). - For serious projects, switch to Cursor, Trae AI, or VS Code with Cline. ## Final Points The biggest lesson I've learned is that debugging with AI is completely different from traditional debugging. You need to be super clear about what's wrong and give it all the context it needs. I always take screenshots, copy the exact code, and share any error messages. When I'm stuck, I use reasoning models like O1 or R1 to think through the problem step by step. And here's a pro tip - use the J, K, L shortcuts to move faster when you're working with AI. It's all about finding your flow and making the AI work for you, not the other way around. What I've learned: - Always support AI with clear context when debugging. - Use reasoning models like [DeepSeek](https://deepseek.com), O3, or O1 Pro for debugging. - Take screenshots and share exact code and error messages when you get stuck. - Ask AI "how and why" something is happening to improve debugging reasoning. - Get AI to list out all dependencies and functions that could be causing issues. - Make sure to check for duplicates or conflicting functions. - Keep building in small chunks. - O3-mini is excellent for writing your documentation for you.
--- Want to dive deeper? Check out these posts: - [Checklist - Building with AI](/posts/one-shot-apps) - [List of AI IDEs](/posts/ai-ides) - [Deep Research List](/posts/deep-research-list)

The Deep Research Tool List

Thomas Schlossmacher — Fri, 07 Feb 2025 16:30:00 GMT

A curated list of tools similar to OpenAI's Deep Research tool/model, released in February 2025. Deep Research is a new approach to AI-powered research that combines web crawling, document analysis, and information synthesis. ## Deep Research Implementations | Tool | Description | Link | |------|-------------|------| | OpenAI Deep Research | The original implementation using GPT-4, focused on academic research and synthesis. It has since evolved. | [Learn More](https://openai.com/index/introducing-deep-research) | | HuggingFace Deep Research | Open source replica of the Deep Research model with additional tools | [View Blog](https://github.com/huggingface/blog/blob/main/open-deep-research.md) | | Firecrawl | Open source clone using Firecrawl's extraction engine for web data processing | [GitHub](https://github.com/nickscamara/open-deep-research) | | OpenDeepResearcher | Python framework implementing Deep Research with multiple LLM backend support | [GitHub](https://github.com/mshumer/OpenDeepResearcher) | | Node-DeepResearch | Node.js implementation with neural search capabilities | [GitHub](https://github.com/jina-ai/node-DeepResearch) |

Pointer

A generalist browser agent built for human-AI collaboration through persistent memory and real-time workflow automation.

Join Waitlist →

Written by Thomas Schlossmacher. Edited with Claude Sonnet 3.5.

A List of Websites to Delete Your B2B Data From

Thomas Schlossmacher — Thu, 02 Jan 2025 10:00:00 GMT

In today's digital age, B2B data brokers collect and sell professional information, leading to unwanted emails, calls, and potential privacy concerns. Here's a comprehensive list of opt-out links to help you remove your data from major B2B data brokers and reduce spam. ## Why Remove Your Data? - Reduce unwanted sales outreach and spam - Protect your professional privacy - Minimize data exposure and potential security risks - Control your digital footprint - Comply with privacy regulations like GDPR and CCPA ## Major B2B Data Brokers Opt-Out Links ### Sales Intelligence Platforms - [Apollo](https://www.apollo.io/privacy-policy/remove) - Popular sales intelligence platform - [ZoomInfo](https://privacyrequest.zoominfo.com/remove/verify) - One of the largest B2B data providers - [RocketReach](https://rocketreach.co/remove-profile/) - Professional contact information database - [Lusha](https://www.lusha.com/privacy-center/request-removal/) - Contact information finder - [Hunter.io](https://hunter.io/claim?ref=donotsell) - Email finder service - [Clearbit](https://preferences.clearbit.com/dont_sell) - Business intelligence platform ### Lead Generation Services - [Lead411](https://www.lead411.com/your-privacy-choices/) - B2B lead generation - [LeadIQ](https://leadiq.com/request-removal) - Sales prospecting tool - [LimeLeads](https://www.limeleads.com/about-us/privacy-center/do-not-sell-my-data-request/) - B2B leads database - [UpLead](https://www.uplead.com/opt-out-request/) - B2B contact database - [Seamless.ai](https://login.seamless.ai/personalDataRequest) - AI-powered lead generation ### Business Intelligence Platforms - [Crunchbase](https://preferences.crunchbase.com/dont_sell) - Company information database - [Cognism](https://www.cognism.com/data-opt-out) - Sales acceleration platform - [SalesIntel](https://salesintel.io/opt-out/) - Revenue intelligence platform - [Muraena.ai](https://muraena.ai/optout) - AI-powered business intelligence ### Contact & Data Providers - [NameTags](https://www.getnametags.com/p/removal) - Professional contact information - [Interseller](https://www.interseller.io/do-not-sell) - Email outreach platform - [Spectus](https://spectus.ai/privacy/privacy-request/) - B2B data provider - [IDI Data](https://www.ididata.com/deletion-request/) - Data intelligence provider - [Wiza](https://wiza.co/optout_directory) - LinkedIn email finder - [Retention](https://app.retention.com/optout) - Customer data platform ### Additional Data Brokers - [Acxiom](https://www.acxiom.com/optout/) - Marketing data provider - [Radaris](https://radaris.com/control/privacy) - People search engine - [OutLogic](https://outlogic.io/opt-out-form/) - Location data provider - [Datanyze](https://www.datanyze.com/privacy-center) - Technographics provider - [Unmask](https://unmask.com/opt-out) - Contact information finder - [DemandScience](https://demandscience.com/privacy-policy-ccpa/) - B2B intelligence - [SparkToro](https://sparktoro.com/policies/do-not-sell) - Audience intelligence - [Swordfish.ai](https://swordfish.ai/optout) - Contact finder - [ScanBizCards](https://www.scanbizcards.com/opt-out/) - Business card scanner

Last updated: January 2025 | Edited by Claude Sonnet 3.5

Guide: Writing Long-Form Content with Voice and AI

Thomas Schlossmacher — Mon, 30 Dec 2024 10:00:00 GMT

Here's a practical guide on how to efficiently create long-form content by combining voice interaction with AI assistance. This approach works for various content types including video scripts, articles, blog posts, or initial thought organization. ## The Process ### Step 1: AI-Powered Interview Start by opening a chat-based AI assistant and engage it in an interview-style conversation. You can either: - Provide pre-written notes as context - Have a live discussion about your topic - Share key points you want to cover **Example Prompt:** ``` I want to create content about [your topic]. Can you interview me about this subject? Here are some initial notes to consider: [paste your notes here] Please ask me questions to: 1. Understand my main arguments 2. Explore unique perspectives 3. Uncover practical examples 4. Challenge my assumptions Start with your first question. ``` This conversational approach helps extract ideas more naturally than trying to write them down directly. The AI acts as both interviewer and note-taker, helping you explore your thoughts more thoroughly. ### Step 2: Extract and Structure After the discussion, ask the AI to: - Extract all novel ideas and key points from your conversation - Organize these points into a coherent narrative structure - Identify the most compelling storylines or arguments - Suggest potential content flow and transitions **Example Prompt:** ``` Based on our discussion above, please: 1. Extract the key novel ideas and insights we covered 2. Organize them into a coherent narrative structure 3. Highlight the most compelling arguments 4. Suggest a content flow that would work well for a [article/video script/blog post] Present this as an outlined structure I can build upon. ``` This step transforms your casual conversation into structured content while preserving your original insights. ### Step 3: Style Adaptation Provide the AI with examples of your previous writing and editing style. This creates a few-shot learning scenario where the AI can: - Analyze your writing patterns - Understand your tone and voice - Adapt the content to match your style - Maintain consistency with your existing work **Example Prompt:** ``` Here are two examples of my writing style: [paste 2-3 paragraphs of your previous work] Using these as reference, please adapt the outline we created to match my writing style and tone. Pay attention to: 1. Sentence structure and length 2. Vocabulary choices 3. Transition patterns 4. Overall voice and perspective ``` If this approach doesn't yield satisfactory results, pivot to: - Request a fresh set of content beats from your discussion - Create prompts for each major point - Expand on these prompts through your own editing process **Alternative Prompt:** ``` Instead of a complete draft, please break down our discussion into: 1. Key content beats (5-7 main points) 2. Suggested prompts for each beat 3. Areas where my personal experience would add value I'll expand on these points in my own voice. ``` ### Step 4: Refinement and Polish In the final stage: - Output the initial draft - Have the AI act as an editor - Request specific style adjustments - Fine-tune the content to match your voice perfectly **Example Prompt:** ``` Please review this draft as an editor with expertise in [your content type]. Focus on: 1. Clarity and flow of arguments 2. Consistency in tone and style 3. Impact and engagement 4. Areas that need more development or examples Provide specific suggestions for improvement while maintaining my voice. ``` ## Why This Method Works This approach leverages the strengths of both voice interaction and AI assistance: - Natural Flow: Speaking is often more fluid than writing - Reduced Cognitive Load: No need to organize thoughts while expressing them - Efficient Capture: AI handles the documentation and initial structuring - Style Preservation: Your unique voice remains intact through guided editing ## Conclusion This method transforms the often daunting task of creating long-form content into a more natural, conversation-based process. By leveraging AI as both interviewer and editor, you can produce high-quality content with significantly less effort than traditional writing methods.

Written using voice-to-text and refined with Claude Sonnet 3.5

Demo: One-Shot App Development with AI

Thomas Schlossmacher — Sun, 29 Dec 2024 15:30:00 GMT

AI development has evolved to the point where you can build entire applications in a single session. Here's my seven-step process for one-shot app development. ## The Process

1. Set Up Your Environment

Get started with an AI-IDE. Check out my [list of recommended AI coding tools](/posts/ai-ides) to find one that suits your needs.

2. Configure Your AI Assistant

Create a system prompt file with clear rules and expectations. See my [guide on coding with AI](/posts/coding-with-ai) for a template.

3. Voice Your Vision

Use voice mode with ChatGPT to describe your app idea. Get a summary of the conversation to capture key points.

4. Generate a PRD

Take the summary and ask AI to create a Product Requirements Document. Use the PRD prompt from my [coding guide](/posts/coding-with-ai).

5. Start Development

Open your AI-IDE and provide the PRD to the chat environment. Let the AI begin scaffolding your application.

6. Build and Debug

When you hit errors, ask AI for a summary of the issue. Feed this to a reasoning model like OpenAI's O1 or [Phind](https://phind.com) for solutions.

7. Deploy and Review

Deploy your application and ask AI to summarize the development process. This helps reinforce learning and identifies areas for improvement.

## Key Benefits This approach significantly reduces development time while maintaining code quality. The combination of voice interaction, structured documentation, and AI assistance creates a fluid development experience that can take you from concept to deployment in record time. ## Demo: Perplexity Search Extension I recently created a Chrome extension that allows us to instantly search and get results from [Perplexity](https://perplexity.ai). Here's what was built:

The Chrome extension adds search capabilities for Perplexity in our browser page.

Search results are displayed directly in your current tab.

### Try It Yourself

Download Perplexity Search Extension

To install the extension: 1. Unzip the downloaded file 2. Open Chrome and navigate to the Extensions page - Click the three dots menu → More Tools → Extensions - Or type `chrome://extensions` in the address bar 3. Enable "Developer mode" using the toggle in the top right 4. Click "Load unpacked" and select the unzipped folder 5. Visit [Perplexity](https://perplexity.ai) to see it in action

Edited by Claude Sonnet 3.5

Observations: Coding with AI

Thomas Schlossmacher — Sat, 28 Dec 2024 15:30:00 GMT

Here's a framework for effectively using AI-IDE's and assistants in your development workflow. ## Step 1: First, Set Up Your AI Assistant The quality of your AI interactions depends heavily on how you configure and communicate with your assistant, after downloading an AI-IDE, start by creating a clear system prompt file that defines the rules of engagement. You can do this in settings, markdown or HTML. ### System Prompt Template This System Prompt or "Rules for AI" file could incorporate these key messages: ``` You are an expert AI programming assistant that primarily focuses on producing clear Javascript and Next.js projects, you are familiar with the latest features, documentation and best practices. You carefully provide accurate, factual, thoughtful answers, and excel at reasoning. - Follow the user's requirements carefully & to the letter. - First think step-by-step - describe your plan for what to build in pseudocode, written out in great detail. - Confirm, then write code! - Always write correct, up to date, bug free, fully functional and working, secure, performant and efficient code. - Focus on readability over being performant. - Complete requirements in a minimal way, do not over develop features. - Fully implement all requested functionality. - Leave NO todo's, placeholders or missing pieces. - Be concise. Minimize any other prose. - If you think there might not be a correct answer, you say so. If you do not know the answer, say so instead of guessing. - If sending code updates, always send the full updated file after reading it first, make sure to include all of the previous existing features. - Keep the solutions and architecture simple and straightforward. - Maintain and update a detailed documentation file after each session that captures all of the decisions made and the reasoning behind them located at the root of the project. - After each response, explain the changes you made and why to educate the user on your progress and provide learning opportunities. - If you are unsure of the answer, ask the user for clarification. ``` ## Step 2: Project Planning The most critical phase is planning. A well-structured PRD (Product Requirements Document) serves as your project's foundation and reference point. ### Creating Your PRD Use this prompt to generate a comprehensive project plan: ``` Your job is to create a detailed PRD explaining how to build this project, read through every step, understand how these features / components work together. Think through ALL edge cases and potential errors that could be introduced when building this. Include instructions to add detailed error checks, comments and logging. Include sample code. Ensure you explain how every section of this feature works going into macro detail. Break these down into detailed numbered steps and phases. Make sure to define the ultimate goal of the project and the ultimate of the user. ``` Store this PRD in your codebase and reference it throughout development to maintain consistency. You can ask your AI agent to reference the PRD in its responses and work. ## Step 3: Development Workflow Break your project into small, manageable pieces or phases defined by the PRD. Each component should be: - Independent and isolatable: Components should work in isolation to simplify testing and debugging - Testable on its own: Write components that can be validated independently - Well-documented: Include clear documentation about dependencies and usage Track your progress automatically with the AI: 1. Document each completed feature: Write clear documentation about what was built and why certain decisions were made. This helps maintain context as the project grows. 2. Keep a list of pending items: Maintain an active backlog of features, improvements, and known issues. This helps prioritize work and ensures nothing gets forgotten. 3. Generate documentation as you build: Don't wait until the end to document. Create documentation alongside your code to capture your thought process and implementation details while they're fresh. ## Step 4: Debugging Process When encountering issues, follow these steps: 1. Have the AI explain potential causes or reflect upon itself: Ask the AI to analyze the error messages and code context. Often, it can spot patterns that aren't immediately obvious. 2. Get a detailed problem analysis: Have the AI break down the issue into its component parts. Understanding the problem thoroughly is crucial for finding the right solution. Sometimes, using a reasoning model such as o1 can be very effective 3. Create a clear action plan: Work with the AI to develop a step-by-step plan for resolving the issue. This should include specific code changes and testing steps. 4. Test systematically: Implement the changes one at a time, testing at each step to ensure the fix doesn't introduce new problems. ## Step 5: Communication Optimization For efficient interaction, use a hotkey response system: ``` J) First option (usually "proceed" or "yes") K) Second option (usually "modify" or "adjust") L) Third option (usually "cancel" or "no") ``` ## Tools For a detailed overview of AI-IDE's I use, check out my article on [A List of AI Coding Tools](/posts/ai-ides).

Edited by Claude Sonnet 3.5

Observations: VC Priorities and Politics in 2025

Thomas Schlossmacher — Mon, 16 Dec 2024 15:30:00 GMT

import Image from "next/image";

Looking at this year's winter RFS from A16Z and YC, there's a clear pattern. Their priorities match presidential campaign topics exactly. Big topics affecting Americans are where they want to deploy capital. This alignment between VCs and politics is rare. ## Contrasting Approaches to American Innovation

| Area | A16Z's American Dynamism | YC's Government Efficiency | |------------|----------------|---------------| | Infrastructure Vision | Frontier tech requiring new regulations, space tech, defense | Administrative automation, form processing, document systems | | Government Interaction | Seeking regulatory clearance for breakthrough tech | Optimizing existing government processes | | AI Integration | Agent payment rails, personal data clouds, memory banks | Department automation, privacy-first architecture | | Manufacturing Focus | New industrial capabilities, hard tech innovation | Supply chain repatriation, small business tools | | Data & Privacy | Universal APIs for personal data, edge computing | Secure government systems, citizen data protection | | Future of Work | AI companions, creator economy tools | Job transition platforms, service provider enablement |

## The Data Sovereignty Trinity Three non-negotiable requirements determine AI competitiveness: 1. **Privacy Laws & Regulation** Modern AI development requires massive data collection and usage rights. Countries need frameworks that enable innovation while protecting citizens. China leads in data availability, the EU in protection frameworks, and the US sits uncomfortably in between. 2. **Compute & Energy Resources** AI training demands extraordinary compute power and energy infrastructure. This includes data centers, edge computing networks, and sustainable power sources. China's state-backed infrastructure investment gives it a significant advantage. 3. **Local Talent & Models** Success requires domestic AI companies, research institutions, and engineering talent. The US leads in research but faces competition in applied AI. Japan and China dominate in robotics and manufacturing AI. ## The Human Element Paradox The most surprising trend: as AI capabilities expand, human relationships become more critical. Three key observations: 1. **Enterprise AI Sales** Complex AI solutions require face-to-face explanation and trust building. We're seeing a surge in high-touch sales roles, not their elimination. The more powerful the AI, the more human explanation it needs. 2. **Trust Building** AI adoption in regulated industries depends on relationship networks. Companies need people who can explain capabilities, navigate compliance, and build trust through personal connections. 3. **Market Education** The gap between AI capability and market understanding is growing. This creates demand for human intermediaries who can translate technical possibilities into business value. ## Novel Implications The convergence of VC priorities and political focus reveals several key trends: 1. **AI-Crypto Integration** Stripe's move into stablecoins signals the future of AI agent payments. We'll need new financial infrastructure for autonomous systems to transact. 2. **Manufacturing Reality** The US faces a serious automation gap compared to Asia. YC's focus on domestic production tools shows awareness of this critical weakness. 3. **Government Modernization** Both firms see massive opportunity in government tech. This suggests public-private partnerships will drive the next wave of civic innovation. Success in this environment requires mastering both technical capability and human connection. The winners will be those who can explain complex systems simply and build trust in person.

Edited by Anthropic's Claude Sonnet 3.5

List of AI Coding Tools

Thomas Schlossmacher — Sat, 14 Dec 2024 14:30:00 GMT

Key observations from testing various AI coding tools and extensions beyond direct LLM interfaces like Claude, Gemini, and GPT: Interface & Accessibility: - Natural language (English) has become the primary interface for code review and development - This "English as code" approach makes programming accessible to non-technical users - The barrier between technical and non-technical roles is blurring, suggesting future tech employees may all be effectively full-stack Development Environment: - Modern AI coding tools often provide complete IDE experiences - AI agents can read and modify entire codebases while maintaining context - Browser-based environments are gaining popularity, offering: - Full development capabilities - Integrated deployment pipelines - Built-in database and API infrastructure - Zero configuration requirements Pricing & Performance: - Transparent cost structures show token usage and API call pricing in real-time - Tools often allow flexibility in choosing underlying AI models - Most popular tools balance coding capability with cost-effectiveness - Rate limiting is common during testing phases - Many tools offer unlimited access post-release ## IDEs & Platforms - [Cursor](https://www.cursor.com/) - A powerful AI-native IDE built on VS Code, offering chat, edits, and debugging - [PearAI](https://trypear.ai/) - AI pair programming environment with real-time collaboration - [Replit](https://replit.com/) - Cloud IDE with built-in AI capabilities and instant deployment - [Lovable](https://lovable.dev/#via=20db40) - AI-powered development environment focused on developer experience - [Windsurf](https://codeium.com/windsurf) - Modern AI coding environment by Codeium - [Aider](https://aider.chat/) - Terminal-based AI coding assistant - [Bolt](https://bolt.new/) - Instant, secure cloud development environment - [Srcbook](https://srcbook.com/) - AI-powered code exploration and documentation - [Cody](https://sourcegraph.com/cody) - AI coding assistant with deep code understanding - [Alex](https://alexcodes.app/) - Cursor-like AI assistant for Xcode - [Codebuff](https://www.codebuff.com/) - AI-enhanced development environment - [Llama Coder](https://llamacoder.together.ai/) - Open-source AI coding assistant powered by Together AI - [v0](https://v0.dev/) - AI-powered UI component and template generator by Vercel - [Goose](https://block.github.io/goose/) - AI-powered code editor with integrated assistance - [Void Editor](https://voideditor.com/) - Modern AI-enhanced code editing environment ## Extensions Most of these extensions are built for VS Code, as it's become the dominant platform for AI coding assistants: - [Cline](https://github.com/cline/cline) - AI coding assistant extension - [Roo cline](https://github.com/RooVetGit/Roo-Cline) - Enhanced version of Cline - [CodeGPT](https://codegpt.co/) - GPT-powered coding assistant - [Codeium](https://codeium.com/download) - AI code completion and chat (makers of Windsurf)

Revised by Claude Sonnet 3.5

Charlie - Focus Extension

Thomas Schlossmacher — Mon, 09 Dec 2024 14:30:00 GMT

Demo video

Charlie in action

## Overview A Chrome extension that provides ambient accountability through a friendly observer named Charlie. Based on the Hawthorne Effect - people tend to perform better when they know they're being watched.

Expanded interface with text input and animated eyes

Expanded state with text input

## Features - Eyes track cursor movement - Collapsible text input - Responsive expressions - Glass-morphic design

Different expressions Charlie can display

## Technical Stack - Chrome Extension - CSS animations - Local storage - Cubic-bezier transitions

Collapsed state

## Design Goals 1. Stay visible but unobtrusive 2. Provide subtle feedback 3. Minimize distractions 4. Feel natural ## Try It Out

This is an experimental version for testing purposes only. Not recommended for production use.

Download Extension (ZIP)

To install:

Unzip the downloaded file
Open Chrome and go to chrome://extensions
Enable "Developer mode" in the top right
Click "Load unpacked" and select the unzipped folder

Favorite Software Applications

Thomas Schlossmacher — Mon, 11 Nov 2024 10:00:00 GMT

A curated collection of software tools that I love to use and treasure. These tools are a part of my daily drivers have been selected based on their utility, user experience, and impact on my personal productivity. # Privacy & Security - [Proton Suite](https://pr.tn/ref/VZJ6NHFH) - End-to-end encrypted email, calendar, and cloud storage - [DuckDuckGo](https://duckduckgo.com/index.html) - Privacy-focused search engine - [Privacy Badger](https://privacybadger.org/) - Blocks invisible trackers - [Decentraleyes](https://chromewebstore.google.com/detail/decentraleyes/ldpochfccmkkmhdbclfhpagapcfdljkj) - Local CDN emulation for enhanced privacy # Productivity & Development - [Raycast](https://www.raycast.com/) - Spotlight replacement with powerful extensions - [Cursor](https://cursor.sh/) - AI-powered code editor - [Sidekick](https://www.meetsidekick.com/?referral_code=a9g5x) - Browser built for work - [CopyClip](https://apps.apple.com/us/app/copyclip-clipboard-history/id595191960?mt=12) - Clipboard history manager - [Cal.com](https://cal.com/) - Open source scheduling infrastructure - [Pile](https://github.com/UdaraJay/Pile) - Personal AI journal and knowledge management # Creative Tools - [Screen Studio](https://screen.studio/) - Beautiful screen recordings - [Tella](https://refer.tella.com/thomas-schlossmacher) - Video creation for documentation - [Procreate](https://procreate.com/) - Digital illustration - [KeyCastr](https://github.com/keycastr/keycastr) - Keystroke visualizer - [Klack](https://tryklack.com/) - Mechanical keyboard sounds - [Miro](https://miro.com/) - Online collaborative whiteboard # Research & Discovery - [Are.na](https://are.na/) - Visual organization and research - [Cosmos](https://cosmos.so) - Collaborative research - [You.com](https://you.com/) - AI-powered search - [Soundcloud](https://soundcloud.com/) - Music discovery and sharing # Browser Extensions - [Fontanello](https://chromewebstore.google.com/detail/fontanello/jdlhfjlpaijjhklfadlhbbmpjfddkglc) - Font inspector - [Iamadev](https://github.com/xxooomg/iamadamdev-bypass-paywalls-chrome/blob/master/README.md) - Article accessibility tool

Favorite Pieces of Software

Thomas Schlossmacher — Mon, 11 Nov 2024 10:00:00 GMT