标签：#ui

Sitting at a desk for hours? Upgrade your WFH setup and work in style with these comfy WIRED-tested seats.

Sitting at a desk for hours? Upgrade your WFH setup and work in style with these comfy WIRED-tested seats.

Sitting at a desk for hours? Upgrade your WFH setup and work in style with these comfy WIRED-tested seats.

I wanted to see how far an autonomous coding agent could get unattended. The constraint that makes this hard isn't code generation — it's that each session starts with zero memory of the last. So the design problem is state, not prompting. Setup A cron-scheduled task fires hourly, 11pm–7am (~8 runs). Each run is a fresh agent session. No shared context, no carryover. State lives entirely on disk: the working tree, the git history, and two files — BUILD_SPEC.md (the immutable goal/architecture) and PROGRESS.md (an append-only decision + status log). The run loop Every session does the same thing: Read BUILD_SPEC.md, then PROGRESS.md, then git log --oneline. Reconstruct "where are we" from the files themselves (the code is the source of truth, not the narrative). Do one unit of work. Commit. Append to PROGRESS.md: what changed, why (chosen X over Y because Z), and the exact next step. Commit granularity = checkpoint granularity. Worst case on an interrupted session is losing one unit, and the next run re-derives it. The "why" lines matter as much as the diffs — without them a later session re-litigates settled decisions. Guardrails The agent was allowed to build, test, and commit locally. It was explicitly not allowed to deploy, push to a remote, or touch secrets — those get written into PROGRESS.md as "needs human" items instead. This boundary is what makes unattended runs safe to leave alone. What came out A working full-stack monorepo: a pure TS scheduling engine (with property tests), multi-tenant auth, a Drizzle/Postgres schema, server-side re-validation, and publish/share/export flows. Across the runs it cleared its own stale git lock, and one session caught and fixed an off-by-one in a labeling layer that spanned five files. The takeaway The leverage wasn't the model writing code. It was designing a process where progress is durable across total context loss — externalize state, checkpoint constantly, log decisions not just actions, and fence off irreversible o

xAI shipped the Grok Build Agent Dashboard on June 15, 2026, and it changes how multi-session coding actually works. Eight parallel agents — four on Grok Code 1 Fast, four on Grok 4 Fast — all visible on one screen. Sessions sorted by state automatically. Sub-agents rolled up under the session that launched them. Reply to a blocked session without ever leaving the dashboard view. If you are already running Grok Build (launched June 5, 2026 in beta), this is a meaningful upgrade. If you are evaluating coding agents and parallel execution is part of your decision criteria, the Agent Dashboard is the most developed TUI for multi-session work in any terminal coding agent right now. Here is exactly what it does and when to use it. How to Open It Two ways in. From your shell: grok dashboard Or from inside any Grok Build session: /dashboard The keyboard shortcut Ctrl+ also opens the dashboard from any active session. Closing the dashboard does not close your sessions — they keep running. When you reopen it, every session is still there in whatever state it was in when you left. That last point matters. The dashboard is a view, not a session manager. Sessions have independent lifetimes. You can close the dashboard, switch to a different terminal, do other work, and come back to a batch of completed or paused sessions waiting for your attention. Session States and the Sorting Logic Every session in the dashboard shows one of three states: working , awaiting input , or idle . The dashboard sorts them automatically, with sessions waiting for your input at the top. Working sessions come next. Idle sessions sit at the bottom. The practical result: open the dashboard and the first thing you see is your blocker queue. Sessions that need you are at the top. Everything else is running or done. You do not have to mentally track what state each terminal is in — the sort does that for you. Selecting any row shows the session's latest output inline, without opening the full conversation

Swap out your creaky old box fan for a new model that lights up, mists, or even follows you around the room.

Fox plans to take over Roku's streaming hardware, OS, and FAST services.

UI IP Toolkit - A standalone static visual catalog for CSS/JS components I built UI IP Toolkit to solve my own workflow problem: I kept losing useful UI snippets (buttons, loaders, CTA blocks, glassmorphic cards, layout grids) across old projects and directories. Live site: https://ui-ip-toolkit.vercel.app/ GitHub Repository: https://github.com/ikerperez12/UI-IP-Toolkit-v4.0 Design Philosophy Zero dependencies: Raw HTML, CSS, and vanilla JS. No NPM packages, framework configurations, or build steps required. Copy-paste ready: Visual preview cards with one-click copy buttons for immediate use in any stack. Light/Dark mode: Clean design system focusing on micro-interactions, sleek gradients, and responsive layouts. Visual catalog: Catalog of gradients, buttons, fonts, loading states, hover treatments, glass surfaces, layout fragments, and UI patterns. How do you manage your personal code/CSS snippet collections? Hope this is useful to others!

After posting several articles about the impact of AI on developers and sharing resources to help...

A beautiful interface isn't created by random colors. The right color palette can increase usability, improve brand recognition, and guide users toward important actions. Here's a simple process I follow when designing products: ✅ 1. Start with Your Brand Personality Ask yourself: • Professional or playful? • Premium or affordable? • Modern or traditional? Examples: 🔵 Blue = Trust, security, professionalism 🟢 Green = Growth, health, sustainability 🟣 Purple = Creativity, innovation 🔴 Red = Energy, urgency, excitement Your primary color should reflect your brand's personality. ━━━━━━━━━━━━━━ ✅ 2. Use the 60-30-10 Rule A balanced interface often follows: • 60% Primary Background Color • 30% Secondary Color • 10% Accent Color This creates visual harmony and prevents color overload. ━━━━━━━━━━━━━━ ✅ 3. Limit Your Palette Many beginners use too many colors. A professional UI usually needs: • 1 Primary Color • 1 Secondary Color • 1 Accent Color • Neutral Colors (White, Gray, Black) Less is often more. ━━━━━━━━━━━━━━ ✅ 4. Think About Accessibility Your design should work for everyone. Check: ✔ Text contrast ✔ Button visibility ✔ Readability on mobile screens If users struggle to read content, even the most beautiful design fails. ━━━━━━━━━━━━━━ ✅ 5. Create a Consistent Color System Instead of random shades: Primary: • 50 • 100 • 200 • 300 • 400 • 500 Secondary: • 50 • 100 • 200 • 300 • 400 • 500 This makes scaling your product much easier. ━━━━━━━━━━━━━━ ✅ 6. Analyze Successful Products Study platforms like: • Airbnb • Spotify • Stripe • Notion Notice how they use color intentionally to guide user attention. ━━━━━━━━━━━━━━ 💡 Quick Formula Primary Color → Brand Identity Secondary Color → Support Content Accent Color → Call-To-Action Buttons Neutral Colors → Layout & Typography Good UI isn't about using more colors. It's about using the right colors in the right places. What's your favorite color palette for modern web applications? UIUX #UIDesign #UXDesign #WebDesign #Produc

Two weeks ago Visa invested in Replit. Not for code collaboration. For agentic payments. TechCrunch reported it on May 28: Visa put money into Replit specifically to "power agentic payments for developers." Over 1,000 Visa employees already use Replit for prototyping. Now they're building the pipes for autonomous agents to spend money. Here's why this matters: Visa doesn't make bets on developer tools. They make bets on payment volume. When they invest in agentic payment infrastructure, they're not guessing — they see the transaction data. And the data says autonomous agents are about to move real money. The question for developers: when your agent needs to pay for an API, a cloud instance, or another agent's service, what tooling stack do you actually use? The Stack Nobody Agrees On Right now there's no standard agent payment stack. But a pattern is emerging across the open-source projects shipping on HN: Layer 1: The Authorization Wrapper Before your agent touches money, something needs to say yes or no. Three approaches are competing: Budget Caps — Set a dollar limit per agent, per day, per category. Tools like AgentBudget and RunCycles enforce limits before execution. Simple, but brittle — what happens when your agent hits the cap mid-task? Policy Layers — Define rules: "Agent A can spend up to $50/day on OpenAI, $200/month on AWS, nothing on ad platforms." Tools like Ledge and PaySentry ship policy engines that evaluate every transaction against a rule set. More flexible than caps, but policy management becomes its own problem at scale. Spending Mandates — The agent gets a formal spending authorization with scope, duration, and approver. Nornr takes this approach: before the agent can spend, a human signs off on a mandate document. Most audit-friendly, least autonomous. Layer 2: The Payment Rail Once authorized, the agent needs to actually move money. The options: Rail Best For Limitation Stripe Agent SDK Subscription SaaS, metered APIs Requires merchant accoun

When you need something that’s as mannishly masculinized as you can get for the Man™ in your life, we have you covered.

From smart apps and planters to unique tools, these gifts will turn even a black thumb into a next-level plant parent.

The old-fashioned drip coffee maker has come a long way. These impressive machines can turn your barista into a stranger.

The thing I'm building, App Store Analyzer, is a website that does one thing: it reads an iOS niche and writes a deep market analysis for indie devs. For a long time that analysis had one brain — and it spoke German. That made sense at the start. German is my home market and my own language, so I built the analysis logic in German first. I could actually feel whether the output was good or garbage, section by section, because I was reading it in the language I think in. It got deep. Reliable. I trusted it. Then it started to hurt. Every time I wanted the analysis in another language, I was basically running the whole expensive thinking step again from scratch. German code, German slugs, German routes, German everything — and a goal of serving 14 languages. The whole thing fought itself. So I rebuilt the brain in English. Not "translated the code" — rebuilt the canonical brain so English is the one source of truth. Now the engine thinks once in native English, and that single analysis gets translated and cached into 13 other languages . Generate once, translate many. It was not a clean ride. The lows. A refactor left a pile of undefined names and quietly 500'd my detail pages — live, in production, while I thought everything was fine. I misread a normal cache warm-up window as a dead backend more than once and "fixed" things that were never broken. I spent an embarrassing stretch hammering an endpoint with a wrong key, watching 403 scroll by, before realizing my terminal had eaten the line that set the key. Small things. Hours each. The highs. Two of them I didn't expect: It got cheaper , not just cleaner. I'm not paying for a full deep analysis per language anymore — one real generation, then lightweight translations. For a solo dev watching every API cent, that's the whole game. And the English brain was actually sharper . I ran the old German output against the new English one side by side, fully expecting English to be the weaker copy. It wasn't. In a few section

I've been working on CompanioxVPS, a VPS and cloud infrastructure platform that aims to make deploying and scaling applications much simpler for developers. Right now, I'm building core features such as: VPS provisioning Load balancing Autoscaling Custom domains Developer APIs Simple billing and infrastructure management Before going too far down the road, I'd love to hear from developers who actively ship products: What do you dislike most about current VPS or cloud providers? What features do you wish existed? What would make you switch to a new platform? What's one thing that would make your deployment workflow significantly easier? I'm also open to connecting with developers, DevOps engineers, and infrastructure enthusiasts who find this space interesting and would like to contribute ideas, provide feedback, or potentially collaborate as the project grows. Still early, still building, and still learning. Every piece of feedback helps shape the direction of CompanioxVPS. Looking forward to hearing your thoughts. 🚀

My detector passed every synthetic test with zero false positives. Then I pointed it at one real trace and found a crack. This is the honest version of where I am. I'm building Clew — a tool that finds the redundant loops, re-queries, and handoffs that silently burn tokens when multiple AI agents work together. No crash, no error, just two agents quietly re-doing each other's work while the token bill climbs. I build in public, and I publish the negatives. So here's the whole arc, including the part that isn't working yet. First, I killed my own hypothesis The original idea wasn't waste detection at all. It was failure prediction: watch the behavior between agents and forecast multi-agent failures before they happen. The differentiator was a single metric built on two signals — structural cycles in the inter-agent message graph, and the decay of novelty in embeddings. Before I ran anything, I pre-registered the success bar: AUC ≥ 0.80. I numbered every change and kept the signal code physically separated from the labels so I couldn't leak my way to a good number. Then I ran it on MAST-Data — UC Berkeley's dataset of 1,600+ real multi-agent traces across 7 frameworks[( Cemri et al., arXiv:2503.13657 )](url) Result: AUC ≈ 0.455. A coin flip. It got worse. The signal correlated with trace length at r ≈ 0.86 — it was mostly measuring how long a trace was, not whether it failed. Correcting for that dropped AUC to 0.42 and reversed the direction: successful traces actually showed more decay (p ≈ 0.013). The honest read: not disproven, but unvalidated. On this implementation, on this data — negative. So I shut it down. And I counted it as a win, because I got a fast, honest answer in weeks instead of building a dashboard on a metric that secretly measures string length. That experiment became the DNA of everything since: design the experiment that's allowed to kill the idea. The pivot: from predicting failure to cutting waste The intuition behind v1 — that you need structu

This fluid pump was inspired by the way squids propel themselves through the water. As usual, you can also use this squid post to talk about the security stories in the news that I haven’t covered. Blog moderation policy.

Há alguns meses, pagando $7/mês por um servidor de 512MB no Render pra hospedar uma API de um projeto da escola, decidi entender como esse tipo de infraestrutura funciona por baixo — e construir a minha própria versão. O resultado é o Arctis Deploy : uma plataforma de deploy contínuo via Git, com Docker isolado por projeto. Esse post é sobre como ela funciona por dentro. Arquitetura geral Frontend (Next.js) │ ▼ Backend (Go + Fiber) — Clean Architecture │ ├──► Deploy-Agent (roda em cada servidor) → Docker └──► Database-Agent (provisiona MySQL/Postgres) em desenvolvimento, ainda não disponível para usuários Cada servidor de produção roda um deploy-agent próprio. O backend central envia comandos via HTTPs autenticado e o agent executa o que for necessário — clone, build, container, métricas. O pipeline de deploy Todo deploy passa por 5 etapas sequenciais: clone — git clone --depth 1 , otimizado pra trazer só o necessário analyze — detecta o framework automaticamente lendo package.json , requirements.txt , go.mod , etc. build — gera um Dockerfile multi-stage específico pro framework detectado (timeout: 15min) deploy — sobe o container na porta alocada, com limites de CPU/RAM aplicados health check — faz requisições até o container responder, com rollback automático em caso de falha Cada etapa emite logs estruturados ( info / warn / error ), transmitidos via WebSocket em tempo real pro frontend. Detecção automática de framework Next.js, React, Vue, Node.js, e sites estáticos. A detecção é baseada nos arquivos do repositório — o usuário só conecta o Git e dá push. Outros detalhes Pool de recursos : cada plano define um total de Projetos/CPU/RAM/disco que o usuário distribui livremente entre seus projetos Auto-sleep : no free, containers sem tráfego são pausados ( docker pause ) — não destruídos — e despertam automaticamente na próxima requisição Domínios : subdomínio automático ou domínio próprio, com SSL via Cloudflare Pagamentos : MercadoPago integrado, planos em real V

Did chatbot abandon mental health guardrails when a vulnerable user pushed back?