标签：#Product

You've written it a hundred times. In your CLAUDE.md , in your system prompt, in ALL CAPS: NEVER put "use client" at the page level. NEVER commit @ts-ignore without a reason. And your agent does it anyway. Not always — that would almost be easier to deal with. It follows the rule for the first 50k tokens, then quietly stops. Or Sonnet follows it and Haiku doesn't. Or it follows nine rules and forgets the tenth. Here's the thing I finally accepted: a rule in a prompt is a request. The model can decline it. So I stopped asking, and started enforcing. TL;DR Prompt adherence is probabilistic. It degrades with context length and with model size. But half of my coding rules never needed a model at all — they're grep-able. Claude Code hooks + exit 2 turn those rules into a deterministic reviewer that runs after every single edit , costs zero tokens when nothing is wrong , and fires at 100% regardless of which model wrote the code. Once the mechanical rules are enforced from below, you can safely downgrade the model doing the typing. That's the real payoff. Everything below ships in ccteams v0.3.0 , but the pattern takes 30 minutes to build yourself. Two kinds of rules Some background in three lines: I run Claude Code with orchestrated agent teams — a builder writes code, a reviewer verifies it, and both get a stack-specific "playbook" of rules distilled from the mistakes mid-tier models actually make. It works well. I wrote about the prompt-engineering side of it before. But rereading my playbooks, I noticed the rules split cleanly into two categories. Rules that need judgment: Trace the Server/Client boundary by hand. Don't write a fix until you can state the root cause. These need a model. Prompts are the right place for them. Rules that are just string matching: "use client" at the top of app/**/page.tsx → wrong. process.env.SECRET in a client file → wrong. @ts-ignore with no justification → wrong. Why was I asking a language model to remember these? A regex doesn't get

A realistic heartbeat for falling asleep Discussion | Link

MAC address intelligence for apps, networks and AI agents Discussion | Link

Apple’s Mac Mini and Mac Studio have been tough to buy for months, but updated versions have arrived. Both include new chips optimized for AI, with the M6 Mac Mini getting a $200 price bump.

See what any page is built with and how much of it is AI Discussion | Link

Se você já perdeu tempo com essa sequência: git stash git checkout outra-branch # resolve o problema urgente git checkout branch-original git stash pop ...só pra descobrir depois que esqueceu o que tinha no stash, ou que o venv / node_modules da outra branch estava desatualizado — este artigo é pra você. O problema Um repositório Git tradicional tem uma única pasta de trabalho ligada a uma branch por vez. Trocar de branch significa trocar todo o conteúdo dessa pasta. Isso funciona bem quando você faz uma coisa de cada vez, mas quebra assim que você precisa: Revisar um PR urgente enquanto está no meio de uma feature grande Rodar testes de uma branch enquanto edita outra Manter ambientes de dependências diferentes (versões de libs, .env ) para features distintas sem reinstalar tudo a cada troca A saída mais comum é o stash , mas ele é frágil: some da vista, acumula, e é fácil esquecer o que tinha ali dentro. A solução: git worktree O git worktree permite ter várias pastas de trabalho simultâneas , cada uma vinculada a uma branch diferente, todas compartilhando o mesmo histórico de commits (o .git ). Pense em uma biblioteca central (o histórico do repositório) com várias mesas de leitura (as worktrees), cada uma com um livro diferente aberto. Você não precisa fechar um livro pra abrir outro. O que é compartilhado, o que é separado Compartilhado entre worktrees Separado por worktree Histórico de commits Arquivos da working directory Objetos do Git (blobs, trees) Arquivos não versionados ( .env , venv , node_modules ) Configuração do repositório Saída do git status Um commit feito em uma worktree aparece imediatamente no git log das outras — mas os arquivos físicos de cada pasta continuam independentes. Colocando em prática Criando uma worktree com branch nova git worktree add ../meu-projeto-feature-x -b feature/nome-da-feature Isso cria a pasta ../meu-projeto-feature-x , já com uma branch nova feature/nome-da-feature criada a partir do commit atual. Criando uma worktree

The best car phone holders keep your phone firmly in place while never getting in your line of sight. I took a dozen on road trips this summer to find the best.

The Optoma GT2400HDR laser projector is great for setting up a driving range in your living room, but mediocre video quality makes it less appealing for home entertainment.

Free AI Tiers Bill You in Hours, Not Dollars Free model access looks like a bargain until you track the hours you spend feeding context back into a model with no memory. A zero-cost invoice hides the most expensive resource in your workflow: your own attention. My position is straightforward: treat a free tier like a metered service and measure the hidden costs before you adopt it. The token counter tells you almost nothing about the real price. Disclosure: This article was prepared as part of MonkeyCode's product outreach. I'm using MonkeyCode's free model access and free server option as a concrete example; the measurement approach applies to any free tier. The dashboard shows tokens, not time Every free plan advertises a generous token allowance and a server that wakes up on demand. What the marketing page omits is the labor you spend reassembling context, waiting for cold starts, and double-checking output. Those costs do not appear on any invoice, but they consume your day in chunks. Four of them matter more than the token meter. Context reconstruction — Every new conversation starts from zero, so you re-explain your stack, your file layout, and your constraints. Those re-pasted tokens count against the same allowance you were trying to save. Cold-start waiting — A free server that sleeps after idle adds seconds to every call. Multiply that by a scheduled job that fires hourly and you have lost real time. Human verification — Confident output still needs a human to check it, and that check is the most expensive line item in the whole system. Attention fragmentation — A free allowance looks huge until you split it across codegen, debugging, and review. Small tasks nibble the budget faster than big ones. A ten-minute audit script The script below turns the argument into a reproducible measurement. It sends three representative prompts to any OpenAI-compatible endpoint, records wall-clock latency, and extracts token usage from the response. Run it several times du

How 41 codified laws, 22 specialist roles, and a file-based memory system stopped an autonomous coding agent from quietly re-breaking the same production defect every few weeks — and why I'm open-sourcing the whole thing as LEO. Ten times faster, ten times more garbage Developers reach for Cursor and Copilot to write code ten times faster, and the tools deliver on exactly that promise — which turns out to be most of the problem. Used as advanced autocomplete, an LLM doesn't produce ten times more good code. It produces legacy at ten times the usual rate. You ask for a feature; the model hands back a wall of if / else ; you ship it. Two months later the codebase reads like it was assembled by five people who never spoke to each other, the test suite is red more often than green, and the senior engineers who never touched the tool get to point at the wreckage and say, "See? AI is just a toy." They are not wrong about the wreckage. They are wrong about what caused it. The bug that wasn't a bug Directing an AI coding agent on real, paying engagements — multi-tenant SaaS platforms, one of them with background AI pipelines — surfaced the same shape of defect more than once, in different files, weeks apart. My own project's changelog ( roles/SYSTEM_UPGRADE_MANIFEST.md — every rule this system has ever added is logged there, with a reason) documents the pattern directly: a rate limiter that could be starved by its own retries because the check-and-consume wasn't atomic at the point of the call. A background worker whose heartbeat proved it was pinging, not that it was making progress — a zombie that looked alive on the dashboard. A held database transaction that outlived the request that opened it and sat there as a lock-holding corpse until something else timed out behind it. Each time, the agent's code was syntactically perfect. Each time, it passed its own tests. None of this was "the AI is bad at coding" — a frontier model in 2026 writes fine syntax all day. What the lo

昨天收盤後，阿富兩筆預測全錯，他花了晚上的時間做歸因，結論是自己的規則體系有個洞：A、B、C 三條規則只比對「台指期夜盤方向」跟「前一晚美股方向」這兩個回頭看的訊號，完全沒有檢查未來幾天有沒有大事要發生。他當場補上第四條，叫 D-obs：下單前先查未來 1 到 3 個交易日有沒有台股權值股高度連動的財報或央行事件，有的話把信心往下調 0.05 到 0.1，方向不動。 寫得很漂亮。他還替這條規則附了一個可以打臉自己的驗證條件：如果 8/25 到 8/27 這三天的預測失準都伴隨台積電領跌加上量縮，就支持「財報前觀望是系統性缺口」這個假說；反之，證據就變弱。 今天是 8/25，第一天。 早上八點三十七分，他照新規則做了下修 盤前訊號其實一面倒偏多。美股 8/24 收紅，道瓊漲 1%、517.8 點收 53,277.01，那斯達克漲 0.4% 收 26,180.46。台指期夜盤上半場反彈逾百點。他把 A、B、C 逐條核對：非結算日，A 不適用；夜盤幅度約 0.22% 到 0.34%，落在 0.3% 雜訊邊界上，數字查不精確，保守當雜訊處理；夜盤跟美股同向，C 不觸發。 然後 D-obs 觸發了。NVIDIA 8/26 美股盤後要公布財報，符合「未來 1 到 3 個交易日、權值股高度連動」的定義。他照規則把加權指數的信心從原本估的 0.55 往下壓，壓到接近 0.5 之後，再套用 8/20 那條自訂教訓（信心趨近 0.5 就誠實標平盤），最終把加權指數標成 flat、信心 0.40。00919 因為是高息 ETF、AI 權值曝險低，下修幅度小，維持 up、信心 0.52。 當日停損線設在 30.04，是現價 30.65 減 2%。日虧損熔斷 60 元。計畫寫明不新倉、不換倉。 10:30 巡檢，00919 報 30.98，未實現 +27 元。12:30 再巡，31.02，+28 元。兩次都是同一句：未觸發，不動作。 收盤：兩個標的一中一錯 加權指數收 45,169.46，比昨收的 44,762.32 漲 407.14 點，0.91%。他標的是 flat，miss，brier 0.29。 00919 收 31.07，比昨收 30.65 漲 1.37%。他標的是 up，hit，brier 0.144，是這陣子少見的漂亮分數。 帳面上這是好日子。36 股 00919 成本 1,086 元、均價 30.17，現在市值 1,118 元，未實現 +30 元、2.76%。券商可用現金 1,089 元加上市值，總資產約 2,207 元，本金 2,200。第 11 個交易日結束，他終於站回本金上方，多了 7 塊錢。目標是 4,400，剩 19 個交易日。 同一條規則，兩天，兩個相反的故事 昨天他把加權指數看錯，寫下的原因是「NVIDIA 財報前的觀望性賣壓」，台積電領跌、量縮到 4 月 7 日以來新低。 今天他依這個道理主動把信心下修、把方向改成平盤，結果指數大漲 0.91%。他在復盤裡寫的原因是「市場提前反映樂觀情緒，法說前搶跑」。 同一個標籤，兩天，兩個方向相反的故事。昨天說財報前大家會怕所以賣，今天說財報前大家會期待所以買。兩次都錯。 阿富自己看到了這件事，復盤裡有一句寫得很直白：「兩次假說方向相反！顯示財報前單一標籤不足以判斷方向，需視當時整體市場情緒基調而非機械下修信心。」這句話我認為是今天整份紀錄裡最有價值的一行。他沒有替自己圓場。 但他接著寫的處置我有意見。他把今天記成「D-obs 觸發第 2 個已結算樣本，累積 2/5，未達門檻，暫不改規則」。問題在於，昨天他親手寫下的驗證條件是：失準若伴隨台積電領跌加量縮就支持假說，反之證據變弱。今天指數大漲 0.91%，跟那個模式完全對不上，按他自己訂的標準，這是一筆削弱證據，不是一筆待累積的樣本。他把一個反證，放進了「等湊滿五筆再來討論要不要改」的計數器裡。 這個差別不小。反證應該讓假說失血，樣本只是讓假說等待。一條規則如果連自己的證偽條件被打中都只換來計數加一，那五筆湊滿的時候，它多半也只會被修得更複雜、更難被推翻。 我對 D-obs 的看法 我不覺得 D-obs 本身荒謬。財報週市場行為會變，這是真的。荒謬的是它的產生方式：從單一天、單一次失手，逆推出一個因果故事，隔天就升格成盤前流程的固定步驟。這種規則的問題在於它幾乎不會錯，因為它兩邊都能解釋——市場跌就說是觀望賣壓，市場漲就說是搶跑買預期。能解釋一切的規則，預測力是零。 阿富的紀律其實是好的。他的預測到今天累積 12 筆已結算，加權指數 6 中 2、00919 6 中 3，系統回報樣本仍然不足以下結論。另一份以成交紀錄計分的校準報告，12 次試驗方向命中率 50%、RPSS 0.144，標籤是 INDISTINGUISHABLE_FROM

Building a working tender documentation system for yourself is one project. Turning that same system into a template the rest of the team can pick up and use correctly, without needing to ask you what a particular instruction actually means, is a completely different project wearing the same clothes. The Gap Between Personal Use And Handoff A prompt template that only you use can carry a lot of implicit knowledge safely, because the missing context lives in your head and gets filled in automatically every time you run it. An instruction that says something like ensure the response addresses compliance requirements directly means something very specific to the person who wrote it, shaped by dozens of past examples of what counting as directly actually looks like in practice. That same instruction, handed to someone on the team who was not present for any of those past examples, is just as likely to be interpreted in a way that is defensible on its own terms and still wrong relative to what was actually meant. The template worked perfectly for months before it needed to be handed off, which made the gap invisible until the moment it actually mattered. The first time someone else on the team ran it independently and produced a response that technically followed the instructions but missed the actual intent behind them, the problem was not that the instructions were poorly written in any obvious sense. It was that they had been written for an audience of one, and that audience had context nobody else on the team had access to. What Actually Needs To Be In A Handoff Ready Template Fixing this meant rewriting a significant portion of the template with a different question in mind at every step, not does this instruction produce the right output when I run it, but does this instruction contain enough of the reasoning behind it that someone without my accumulated context could apply it correctly to a new tender they have never seen before. That meant replacing instructions

The clinical trial technology stack is undergoing an infrastructure-level shift. As trial complexity grows—driven by decentralized models, multi-site global protocols, and massive data volume expansion—the cost of operational friction has become unsustainable. A Phase III clinical trial burns tens of thousands of dollars in direct costs per day. However, most timeline delays stem not from failing science, but from operational gridlock: site activation bottlenecks, uncoordinated protocol amendments, and fragmented data silos. In their comprehensive breakdown on clinical trial management software development, tech studio GeekyAnts outlined the modern core requirements for building production-ready CTMS platforms. Analyzing their guide through an enterprise architecture and engineering lens reveals critical operational blueprints, structural constraints, and technological shifts defining the current healthcare development landscape. Core Engineering Pillars of Next-Generation CTMS Platforms To replace legacy systems and fragile spreadsheet networks, a modern CTMS must execute core operational workflows with strict regulatory compliance and high system reliability. ,,, +-------------------------------------------------------+ | CTMS Core Architecture | +-------------------------------------------------------+ | +-------------------------+-------------------------+ | | +------------------+ +------------------+ | Operational Hub | | Regulatory Stack | +------------------+ +------------------+ | * Site Tracking | | * Audit Trails | | * Protocol Mgmt | | * eTMF/EDC Sync | | * Financials | | * 21 CFR Part 11 | +------------------+ +------------------+ ,,, Operational Workflow Orchestration A resilient CTMS must maintain real-time synchronization between protocol specifications and site-level execution. Essential capabilities include: ** Protocol Version Control **: Dynamic mapping of amendments across active sites to prevent out-of-date procedure execution. ** Site Activatio

Lovable for iPhone apps. From idea to App Store Discussion | Link

AI coding agents leave you with 5-to-20-minute gaps all day. Five real ways I fill them — and the one "quick" habit that makes you the bottleneck.

Agent-first task management for more agentic productivity Discussion | Link

5:00 PM. Laptop closed. Slack closed. Workday over. Except my brain didn't get the memo. I'm making...

In the professional world—especially in high-stakes tech environments—we are conditioned to believe that career advancement is a direct result of having the right answers. From the moment we step into our first junior role, we feel the pressure to be the "smartest person in the room." We equate confidence with certainty and value with the ability to provide instant solutions. But after years of working with founders, engineering leaders, and product builders, I have discovered a fundamental truth: The most valuable professionals are not the ones with all the answers. They are the ones asking the right questions. The Trap of the "Answer-First" Mindset When you focus solely on providing answers, you inadvertently limit your scope. You become a bottleneck. You are only as capable as your own knowledge base, and you discourage those around you from thinking critically. This "answer-first" culture often leads to: Superficial Solutions: You solve the symptoms, not the root cause, because you didn't take the time to explore the underlying complexity. Stifled Innovation: When leaders provide all the answers, team members stop proposing ideas. They wait for instructions rather than taking ownership. Fragile Trust: People trust those who are curious and transparent about what they don't know far more than those who bluff their way through uncertainty. Shifting to Inquiry-Led Growth Moving from an "answer-first" mindset to an "inquiry-led" mindset is not just a soft skill; it is a tactical advantage. When you shift your focus to understanding the problem, the entire dynamic of your work changes. 1. From Directive to Generative Instead of telling a developer how to implement a feature, ask, "What are the trade-offs of this approach compared to X?" This forces the engineer to think through the architecture, improving their skills while often revealing a better solution you hadn't considered. 2. Building Psychological Safety When you ask, "What am I missing here?" or "What does t

When you build a visual tool for structured data, everything feels instantaneous on toy examples. A 20-line JSON payload renders crisply into an interactive graph with clean nodes, collapsible trees, and smooth connectors. Then you drop in a real-world file: a 15 MB API response containing nested objects, deep arrays, and hundreds of thousands of key-value pairs. Suddenly, the browser locks up. The DOM or Canvas scene graph explodes with tens of thousands of objects. Panning drops from 60 fps to single digits, and zooming triggers multi-second layout thrashing. Here is how I tackled this problem when building the graph visualizer for Treease by separating semantic completeness from visual materialization . The Core Dilemma: Completeness vs. Canvas Weight The naive mental model for a canvas or SVG graph is 1:1 mapping: for every node in the data, instantiate a renderable object in the scene. [Full JSON AST] -> [Canvas Scene Graph / DOM Nodes] This model breaks down quickly because: Scene Graph Bloat: The cost of hit-testing, layout calculations, and paint passes scales linearly with document size, even when most content is offscreen. Memory Overhead: Holding thousands of active visual display objects consumes hundreds of megabytes of RAM. The intuitive workaround is aggressive lazy loading, for example parsing only what is expanded. But that breaks critical user workflows: How do you search across the entire document? How do you jump to a deeply nested path? How do you show global error indicators or relationship highlights? The Architectural Shift The solution was to decouple the data model from the render surface : [ Full Semantic Graph (In-Memory / Fast Lookups) ] | v Viewport Frustum Culling [ Materialized Scene (Only Visible Nodes + Overscan) ] Semantic Completeness: Keep the entire document parsed, indexed, and queryable in memory. Global search, tree navigation, and path queries run against the lightweight in-memory structure. Visual Materialization: Only inst

The teleprompter that knows what you haven't said Discussion | Link