标签：#t

What AI makes, Publia ships. Discussion | Link

Obsidian prompts beat open-ended reflection every time: median review time across 6 weeks was 14 minutes, fastest was 9, slowest was 22 (and that week genuinely deserved 22). I ran the GTD-adjacent version faithfully for six weeks — 90 minutes, full capture sweep, energy audit, the works. Then less faithfully for two months. Then I stopped entirely and didn't notice for three weeks. That last part is the failure mode nobody writes about. The format wasn't wrong; it was sized for a version of my week that rarely existed. The fix wasn't a better framework. It was shorter, closed questions. My Obsidian template has seven prompts, none of them open-ended: what shipped, what didn't, what I avoided and why, one thing to drop, one thing to protect. One-to-three sentence answer ceiling per prompt, hard stop. Open questions like "how was your week?" generate rumination. Closed questions generate decisions. That distinction is doing almost all the work. The Notion version I ran before this taught me something useful about tool selection too. I built rollups — tasks closed this week, open tasks by project, inbox count, stalled for 7+ days — and they worked exactly as designed. What Notion couldn't do was get out of its own way during actual reflection. Every time I tried to think through what went wrong, I'd end up reorganizing a database instead. Forty minutes later, new linked database, zero review completed. The same flexibility that makes Notion a good data layer makes it a bad "close the loop and move on" environment. Obsidian's plain-file simplicity is the right call for the thinking layer — and completely wrong for the data layer. Neither tool alone is the honest answer. There's also a cautionary note from my automation setup: a Zapier zap that pushed completed tasks into Notion for weekly rollup ran cleanly for two months, then silently broke when my task manager updated their API response format. Modified tasks started logging as completed. My rollup became noise befo

That's the reality of what I've been testing - whether you can actually run a micro SaaS from a phone. Not as a gimmick, but as a real workflow. The key is prompting discipline. When I want a changelog section added to my delivery page, I'm not just asking. I'm structuring the task: queue it up, do QA after each step, create the build, update the OTA link, ping me on Telegram, then move to the next one. If something breaks, take notes and continue - I'll deal with it later. The AI handles the repetitive loop. I handle the decisions. Most of my dev ops now fits in a chat thread. Is this the future of solo building? Maybe. Or maybe it's just a useful edge case for when your laptop is in for repair and you have a deadline. Either way, it's worth knowing what's actually possible.

Three days into November, a disapproval cascade pulled 40% of active SKUs from Shopping and Performance Max simultaneously — on day one of a promotional window we'd spent six weeks building. No feed changes on our side triggered it. Here's the part most guides miss: Google's automated review threshold for certain policy categories (health claims, price accuracy, before/after imagery) tightens as platform ad volume increases heading into Q4. I've watched this happen across accounts running ₩50M–₩120M/month in combined Google spend, three years in a row, with zero feed-side changes preceding it. Same feed that sailed through August catches 15–20% disapprovals on recheck in September. The products didn't change. The enforcement did. When it hits during a live window, fix order matters more than fix speed. Price mismatches go first — not because they're the most dramatic, but because they cascade silently. One bestseller disapproved during a flash sale means Performance Max quietly reallocates budget to lower-performing products. By the time ROAS visibly drops, you've lost 48 hours of peak traffic. The specific failure mode I've seen twice on Cafe24 with direct API feeds: a site-wide price update propagates to the feed before the landing page CDN cache clears. Google crawls the feed, sees the new price, crawls the landing page, sees the old cached price. Mismatch. Disapproval. Fixing it is one line — force a manual fetch and verify sale_price_effective_date formatting — but finding it at 2am during a live sale is a different problem. Prohibited content disapprovals are deprioritized by most teams because they're rare. That's exactly wrong. A single escalation during Black Friday week can trigger account-level review, not just product suspension. Pull the SKU yourself within the hour if you can't fix the content immediately. Suspending your own SKU is recoverable. A suspended account during peak is not. GTIN and identifier issues — despite getting the most attention in s

Dispatchers AI Co-Pilot and Dashboard that care about speed Discussion | Link

Your coding agent's missing tool: image generation Discussion | Link

On June 9, 2026, Anthropic launched Claude Fable 5, a model designed for long-horizon tasks, but it was taken offline shortly after due to a U.S. government export directive. It shares architecture with Claude Mythos 5, supporting extensive token usage. The model includes mandatory data retention requirements, which have affected its deployment with partners like Microsoft. By Andrew Hoblitzell

Broadcom released Spring Boot 4.1 on June 10, 2026, to deliver gRPC auto-configuration, HTTP-client SSRF mitigation, and upgrades to Kotlin 2.3. It also brings lazy datasource connections, async context propagation for @Async methods, and improved OpenTelemetry support. Uncharacteristically, Broadcom moved the releases twice, first from May 11-22 to June 1-5, then to June 8-12. By Karsten Silz

Meme Monday! Today's cover image comes from the last thread. DEV is an inclusive space! Humor in...

Orbio announces $21 Million Series A in round led by Dawn Capital.

Cómo un backend de FastAPI + asyncpg comparte un solo Postgres chiquito con sus propios trabajadores en segundo plano y un segundo servicio, por qué el techo de conexiones, no el CPU, es lo que de verdad le pone tope a nuestro autoescalado, la caída en el cambio de hora que nos enseñó la cuenta, y una mirada honesta a RDS Proxy como la válvula de escape (incluyendo la trampa de asyncpg que lo puede dejar sin hacer nada). TL;DR Ajuste Valor Por qué Driver postgresql+asyncpg asíncrono hasta el fondo pool_size / max_overflow 8 / 12 (20 por proceso) subido desde 3/5 después de una caída pool_pre_ping True mata los sockets muertos tras un reinicio de RDS / inactividad pool_recycle 1800 s techo duro que el pre-ping no puede cubrir Tope de conexiones de RDS ~87 (t3.micro, menos las reservadas) la verdadera restricción de todo Pruebas NullPool sin pooling entre event loops en pytest La lección que replanteó todo el problema: en un RDS chico, tu cuenta máxima de tareas la fija max_connections , no el CPU ni la memoria. Un autoescalado que ignora el presupuesto de conexiones va a escalar directito hacia QueuePool limit reached , o peor, FATAL: too many connections del mismo Postgres. El pool, y la cuenta escondida adentro de él engine = create_async_engine ( settings . DATABASE_URL , connect_args = { " ssl " : " prefer " }, # negocia TLS en RDS, texto plano en local pool_pre_ping = True , pool_size = 8 , max_overflow = 12 , # 8 + 12 = 20 conexiones por proceso pool_recycle = 1800 , ) Veinte conexiones por proceso se ven modestas hasta que las multiplicas por cada capa entre ellas y la base de datos: pool_size + max_overflow = 20 por proceso de Python × 2 trabajadores de uvicorn = 40 por tarea de Fargate × 2 durante un despliegue rolling = 80 (tarea vieja drenando + tarea nueva arrancando) + servicio de inteligencia (3 + 7) = 10 sobre la misma base de datos + alembic / ad-hoc / psql ≈ unas pocas ---------------------------------------- ≈ 87 ← el techo de la t3.micro, con ~0 de

AI Builder Notes - Week of June 14, 2026 My thoughts and my twitter’s feeds thoughts This week was all about the ‘loop’ and Fable . The Loop The best way I can describe it is: design the flowchart. Think of the deterministic flowchart on how you want your agents to work. Aim to have: more deterministic bits - this keeps things more predictable more verification bits - this is agent feedback more agent tool calls - this, on a frontier LLM, makes it perform better. The ‘loop’ is essentially: goal -> agent acts -> verifier checks -> state/memory updates -> policy decides next action -> repeat/stop/escalate now the specific implementation of this - will differ based on what you’re working on. Fable Fable capabilities are absolutely insane, I tried it myself and it is entirely worth it for you to spend 2 minutes looking at this. There are a few projects that I fire up a new model into to see what’s it gonna do. A project I wanted to build was a way to teach and demonstrate ‘spin’ in table tennis, every frontier model before Fable fumbled hard. But Fable outshined them with ease: https://srijanshukla.com/artifacts/spin-lab/ If you personally did not experience a big shift in capability, you are probably not asking it a complex enough or ambitious enough task. Fable came, and Fable was taken away. The United States Government(USG) was reported with a jailbreak or sorts - which Anthropic considers not significant. The USG anyway banned Fable just after few days of release. Big drama. Fable was very pricey $$$$ Hence, people developed some patterns of work on those few golden days of Fable being available. - use Fable as planner/architect/taste/spatial/front-end judge. - use GPT-5.5/DeepSeek/Kimi as executor/worker. Other things Openrouter released their Fusion feature as a model on their platform, accessible via API. Fusion is basically council-of-LLMs pattern - providing results that can rival the frontier Fable 5 solo. Google Open Knowledge Format - https://github.com/Goo

When I shipped Trooper , a privacy-aware LLM proxy written in Go, I didn't have a marketing plan. I had GitHub traffic analytics and a habit of checking them obsessively. Seven weeks later, I have something more useful than a viral moment: a ranked table of every traffic spike, what caused each one, and proof that the exact same playbook that worked at launch still works when you have something new to say. What is Trooper? Trooper sits between your app and your LLM provider. When your cloud quota runs out, it automatically falls back to a local Ollama instance with zero code changes on your end. It also tracks session context, so your agents don't go blind between calls. It's not a chatbot wrapper. It's plumbing. Which makes the distribution story more interesting, because plumbing doesn't go viral the way demos do. The Data GitHub gives you 14-day rolling windows for clones and views. I screenshotted them obsessively and tracked every spike. Here's the full ranked table: Rank Date Clones Unique Cloners Views Unique Visitors Driver 🥇 1 May 13 375 173 1,113 ~140 Reddit wave peak 🥈 2 May 10-12 312 137 974 133 Reddit launch spike 🥉 3 Jun 10 289 124 749 101 "Escalate the model" r/ollama post 4 Jun 11 268 112 840 95 Decaying from Jun 10 spike 5 Jun 12 240 99 739 74 Decaying from Jun 10 spike 6 Jun 9 175 102 802 100 Organic 7 Apr 25 174 71 664 113 Early Reddit posts 8 Jun 7 171 110 876 110 Organic recovery 9 Jun 6 163 104 755 102 Organic recovery 10 May 29-30 122 73 610 83 LinkedIn post 11 May 25 76 48 495 53 Claude Code integration chat What I learned 1. Reddit is the only thing that moved the needle, and community fit matters more than size The #1 and #2 peaks were both Reddit-driven. On May 10-11, I posted across r/ollama, r/LocalLLM, r/ClaudeCode, and r/Gemini simultaneously. Total views across those posts: ~7,000. r/ollama alone drove nearly 4,000 of those views. Not r/LocalLLM. Not r/ClaudeCode. r/ollama , the smallest of the four communities. The reason: Trooper so

On June 9, Anthropic shipped Claude Fable 5 — the most capable coding model the industry had ever seen. Three days later, the U.S. government ordered it offline for every user on Earth . No warning. No transition period. One directive, and the frontier vanished overnight. 📖 Read the full version with charts and embedded sources on ComputeLeap → The same week, Z.ai (Zhipu AI) released GLM-5.2 — a 744-billion-parameter coding model with a one-million-token context window, MIT-licensed open weights arriving within days. The timing was not lost on the developer community. ℹ️ The message landed clearly on Hacker News: as user Reubend put it, they're "grateful to Chinese labs for being open with their work" — especially after "the Fable 5 fiasco." Open weights aren't just a cost play anymore. They're insurance. This guide walks you through actually running GLM-5.2 on your own hardware — the VRAM you need, the quantization that fits, and the exact commands for llama.cpp, Ollama, and LM Studio. No API keys. No cloud dependency. No one can pull the plug. What GLM-5.2 Actually Is GLM-5.2 is the third major iteration in Z.ai's GLM-5 line, purpose-built for agentic coding and long-horizon software engineering . Here is what you are working with: Spec Value Architecture Mixture-of-Experts (MoE) Total Parameters 744 billion Active Parameters ~40 billion per token Context Window 1,000,000 tokens Max Output 131,072 tokens Training Data 28.5 trillion tokens License MIT (open weights) Thinking Modes High and Max The MoE architecture is the key to local viability. Only ~40 billion parameters fire per token — the rest sit idle. That is what makes aggressive quantization work: you are compressing 744B weights, but inference only touches a fraction of them at any given time. GLM-5.2 supports two thinking-effort presets: High and Max. Z.ai recommends Max as the default for coding work — it produces longer reasoning chains before generating output. The model launched on June 13 on Z.ai's C

When to choose ansible roles over playbooks depends on the need for reusable structure, clear separation of concerns, and scalable maintenance across many environments. In a deployment that touches 1,200 servers, the early design decision determines whether the codebase remains maintainable or devolves into ad‑hoc tasks that require weeks of debugging. 📑 Table of Contents 📦 Modularity — Why Structure Matters 🧩 Reusability — When Scaling Demands Roles 🔧 Example: Deploying a Database Across Multiple Environments ⚙️ Dependency Management — How Requirements Influence Choice 🔗 Role Dependency Example 📁 File Layout — Organizing Artifacts for Maintenance 📊 Performance & Execution — Impact on Runtime 🔍 Comparison – Roles vs. Playbooks 🟩 Final Thoughts ❓ Frequently Asked Questions When should I still use a flat playbook? Can I mix roles and tasks in the same playbook? How do I test a role without affecting production? 📚 References & Further Reading 📦 Modularity — Why Structure Matters Roles enforce a predictable directory hierarchy that isolates tasks, variables, handlers, and files. What this does: # roles/webserver/tasks/main.yml - name: Install Nginx apt: name: nginx state: present - name: Deploy configuration template: src: nginx.conf.j2 dest: /etc/nginx/nginx.conf mode: '0644' notify: Restart Nginx # roles/webserver/handlers/main.yml - name: Restart Nginx service: name: nginx state: restarted tasks/main.yml: defines the ordered steps the role performs. handlers/main.yml: runs only when notified, preventing unnecessary restarts. The directory roles/webserver groups all related artifacts, making the role portable. Because the role encapsulates its logic, a playbook can invoke webserver without repeating internal steps. This eliminates duplication and aligns with the DRY principle. Key point: Enforced structure turns a loose collection of tasks into a self‑contained unit that can be shared across multiple playbooks. 🧩 Reusability — When Scaling Demands Roles Roles enable r

"Files never leave your browser" is becoming standard copy for PDF tools, image editors, and document converters. But a trust claim and a verifiable fact are different things. Here's how to turn "zero upload" into something any user can audit in about two minutes, and how to enforce it at the browser level so it isn't just a promise. Step 1: Read the Network panel Open DevTools → Network, enable "Disable cache", reload. While processing a file, filter by "Fetch/XHR" and "Doc". A genuinely client-side tool should show only HTML/CSS/JS/WASM asset loads — no POST requests, no GETs carrying file content in query parameters. The non-obvious trap: third-party analytics, Google Fonts, and CDNs all show up as outbound requests. If you claim zero uploads, those count too. The honest move is to self-host fonts and scripts and drop analytics entirely, so the request list is genuinely short enough to eyeball. The Network panel is the human-readable check. The next part is what actually makes it hold. Step 2: Enforce egress with CSP connect-src This is the piece people get backwards, so it's worth stating precisely. CSP's connect-src is an egress allowlist the browser enforces before the request is sent . A fetch /XHR to an origin that isn't on the list is blocked by the browser and never leaves the machine. You'll see it fail in the console as a CSP violation, with no entry in the Network tab going out to that origin. This includes no-cors requests. no-cors is sometimes assumed to be an escape hatch, but it isn't one for this purpose. All no-cors does is let you issue a cross-origin request while making the response opaque (you can't read the body). It does not bypass connect-src : if the target origin isn't in your connect-src allowlist, the no-cors request is blocked exactly the same way — it never goes out. So you can't smuggle a file out to a third party with no-cors under a tight CSP. That's what makes CSP the actual proof, not just documentation. Tighten connect-src to 's

We open sourced Centaur last month—a Slack agent we built for our own investing and engineering work. Over the past few months it's grown to 100-150 daily power users across a few organizations, handling both judgment-heavy tasks like investment research and raw horsepower work like searching massive codebases. The interesting part isn't just our internal use. We've been running a small Slack Connect with external orgs using it, and the feedback has been consistent: most SaaS tools don't cut it because companies need too much customization and their critical integrations aren't supported out of the box. Our roadmap is getting clearer as we tackle the tricky parts of multi-org collaboration. We're working on scoping Slackbot access by channel, which would finally let different organizations' agents coexist safely in the same space—almost like an Enterprise Matrixbook. But the real challenge isn't the vision, it's execution. Keeping costs low while staying self-hostable for smaller teams has forced us to rethink everything. The hard problems only become obvious once you're deep in the implementation. That said, I do think Slack has won in one sense: it's the best place for a coworker agent to emerge, rather than a standalone application. Curious whether others are seeing this pattern too.

Hermes-Crew Hybrid: A Hybrid Architecture for Secure Multi-Agent AI Workflows I built a hybrid system that combines a central orchestrator (Hermes) with temporary CrewAI micro-crews, protected by 3 layers of security. Here's what it does and why it matters. The Problem Multi-agent AI systems are powerful but dangerous. When you chain multiple agents together, a single compromised agent can poison the entire workflow. Existing solutions are either too heavy (enterprise PKI infrastructure) or too light (basic regex filters). The Solution: 3-Layer Security Layer 1 — Pre-execution (MCP Tool Auditor): Before any agent can register a tool, it's audited for malicious instructions. Layer 2 — Runtime (Agent Fixer Stage): Every output from every agent passes through a 3-stage pipeline (normalization → pattern matching → embeddings) in under 1ms. Layer 3 — Pre-commit (Code Safety Hook): Before any git commit lands, the diff is analyzed by CrewAI + Ollama local. Malicious code gets rejected automatically. Architecture Hermes (Director) │ ├── MCP Tool Auditor → verifies tools before registration │ ├── Execution: venv (fast) / Docker (isolated) / auto (smart) │ ├── Agent 1: Researcher │ ├── Agent 2: Analyst │ └── Agent 3: Writer │ ├── Security Gateway (Agent Fixer Stage) → filters output (<1ms) │ └── Consolidator → parses output + generates Obsidian notes What Makes It Different 1. Portable by design. Zero hardcoded paths. Every user configures their own .env . 2. Multi-model via LiteLLM. Works with Ollama local, OpenAI, Anthropic, Gemini, Groq, OpenRouter — any provider. 3. Local-first. Everything runs on the user's machine. No cloud dependencies required. 4. Obsidian integration. Every analysis generates a structured note with YAML frontmatter. Code Safety Hook in Action When you run git commit with malicious code: ❌ [ COMMIT RECHAZADO] Code Safety detected risks: → CrewAI detected vulnerabilities: VERDICT: FAIL → Agent Fixer Stage detected anomalies: High threat score: 1.05 Fo

Ever started a new project and found yourself rebuilding the same modal, dropdown, toast notification, tabs, and switches for the 20th time? I got tired of that. So I built UltraHTML , a lightweight UI library that gives you modern components with simple HTML and JavaScript, no framework required. Getting Started Include the CSS and JS files: <link rel= "stylesheet" href= "dist/ultra.css" > <script src= "dist/ultra.js" ></script> Initialize UltraHTML: Ultra . init (); Done. Buttons UltraHTML includes two button styles out of the box: ultra-button — a clean, modern button. ultra-button-wave — adds a wave/ripple-style interaction effect. Basic button: <button class= "ultra-button" > Simple Button </button> Wave button: <button class= "ultra-button ultra-button-wave" > Wave Button </button> Buttons use UltraHTML's default green theme, but because they're standard HTML elements, you can easily customize them with CSS. For example, here's a red button that displays a popup message: <button onclick= "Ultra.popupmsg('Hello from UltraHTML!')" class= "ultra-button ultra-button-wave" style= "background-color: red" > Show Popup </button> You can create buttons that match your site's branding without learning a separate theming system: <button class= "ultra-button" style= "background-color: #3b82f6;" > Blue Button </button> <button class= "ultra-button ultra-button-wave" style= "background-color: #f59e0b;" > Orange Button </button> <button class= "ultra-button ultra-button-wave" style= "background-color: #ef4444;" > Red Button </button> UltraHTML handles the styling and interactions while still giving you full control over how your buttons look. Modal Example Need to display important information? <script> window . addEventListener ( " load " , () => { Ultra . init (); Ultra . modal ({ head : " Important " , text : " You need to reset your password " , buttonText : " Reset " , buttonAction : ( modal ) => { console . log ( " Going to reset page... " ); modal . remove (); } }); }

Why This Matters: The 2 AM Problem It's 2 AM. Your phone rings. Your production database is down. Customers can't log in. Revenue is dropping by the second. You call the Ops team. They restart the server. Downtime: 45 minutes. Cost: $100K in lost sales. Root cause? Unknown. This happens thousands of times a week at companies worldwide. The question isn't "Will your system break?" It's " When it breaks, are you ready? " That's where SRE comes in. What is SRE? (The Real Definition) SRE (Site Reliability Engineering) = Applying software engineering principles to build reliable, scalable infrastructure and systems. It's not just about keeping servers running. It's about: Reliability : Systems that don't break unexpectedly Scalability : Systems that handle growth without collapsing Infrastructure : Automating how systems are built, deployed, and monitored Measurability : Knowing exactly how your system is performing at any moment Traditional operations manages infrastructure reactively — when something breaks, you fix it. SRE manages infrastructure proactively — you engineer it so it rarely breaks, and when it does, it heals itself. The Key Insight: Reliability is Engineered, Not Hoped For Here's the critical shift in thinking: Old mindset : "Let's build this system and hope it doesn't break." SRE mindset : "Let's measure what 'reliable' means, design the system to achieve that, and automate the monitoring and recovery." But reliability isn't just uptime. It includes: Uptime : Is the system available? Latency : How fast does it respond? (A slow system is effectively broken) Error rate : What percentage of requests fail? Throughput : Can it handle the traffic? User experience : Does the system meet user expectations? All of these are engineered and measured. A Simple Analogy: The Bridge Imagine you're managing a bridge. Traditional approach : Engineers patrol daily, react to problems, work around the clock fixing issues SRE approach : Engineers design monitoring that aler