标签：#productivity

Integrating plugins into Claude Code can turn standard AI prompts into automated developer workflows. Based on my recent blog Collection of 10 Amazing Claude Code Plugins on Medium, here is a concise overview of 10 useful plugins and how to install them: 1. UI UX Pro Max Purpose: Provides design guidance for color schemes, font pairings, layout structures, accessibility standards, and responsive UI design. Commands: /plugin marketplace add nextlevelbuilder/ui-ux-pro-max-skill /plugin install ui-ux-pro-max@ui-ux-pro-max-skill 2. GitHub Purpose : Connects directly to your repositories so Claude can navigate codebases, inspect pull requests, and analyze issues without manual copy-pasting. Commands: /plugin install github@claude-plugins-official 3. Code Review Purpose : Leverages multi-agent execution to analyze pull requests for potential bugs and verify adherence to your project's CLAUDE.md guidelines. Commands: /plugin install code-review@claude-plugins-official 4. Superpowers Purpose: Structuring development iterations by guiding Claude through problem discussion, plan creation, test writing, feature implementation, and code review. Commands: /plugin install superpowers@claude-plugins-official 5. Hookify Purpose : Converts prompt guardrails into Markdown rules and automated hooks that warn or block prohibited actions (e.g., debug console outputs). Commands: /plugin install hookify@claude-plugins-official 6. Overnight Dev Purpose: Facilitates long autonomous coding tasks using pre-commit Git hooks running linter checks, automated test suites, and coverage evaluations. Commands: /plugin marketplace add jeremylongshore/claude-code-plugins-plus-skills /plugin install overnight-dev@claude-code-plugins-plus /overnight-setup 7. Claudebase Purpose: Backs up and restores custom Claude Code settings, agents, and rules via a private GitHub repository with support for multiple configuration profiles. Commands: /plugin marketplace add jeremylongshore/claude-code-plugins-plus-ski

AI applications used to be relatively simple. A user sent a prompt. An application sent that prompt to a model. The model returned an answer. The application displayed it. That architecture is changing quickly. Modern AI applications increasingly retrieve information, call external APIs, execute tools, interact with databases, invoke multiple models, run background tasks, maintain state, and sometimes delegate work to other AI agents. At that point, you are no longer building a simple application with an AI feature. You are building a distributed system. This shift is one of the most important architectural changes happening in software engineering today. Google Cloud's recent work on distributed AI agents describes architectures where specialized agents operate as separate services and communicate through orchestration layers. OpenAI's agent guidance similarly describes systems built around models, tools, orchestration, guardrails, and potentially multiple agents. The interesting part is that this transformation is happening even when developers do not intentionally choose a distributed architecture. The Simple AI Application Architecture Consider a basic AI-powered application: User | v Frontend | v Backend | v LLM API | v Response This is straightforward. The backend receives a request, sends it to a model, receives the result, and returns it to the user. There are already challenges around latency, cost, authentication, rate limits, and error handling, but the architecture remains relatively easy to reason about. Now imagine adding a few real-world capabilities. The AI needs to: Search the web Read company documents Query a database Call an external API Remember previous interactions Generate structured output Run background jobs Validate its own output Ask another model for verification The architecture starts looking very different. +----------------+ | Web Search | +-------+--------+ | v +--------+ +----------------+ +------------+ | User +------->| AI Backen

If you write product requirements, technical notes, release plans, or team documentation in Confluence, you have probably lost time fixing formatting after pasting a draft. Headings collapse into plain text. Tables need to be rebuilt. Important callouts lose emphasis. A quick documentation update turns into a manual cleanup session. I built Text to Confluence Editor to make that workflow faster: 👉 Try Text to Confluence Editor What it does Text to Confluence Editor is a free browser-based workspace that converts plain text, Markdown, and document drafts into Confluence-ready rich content. The workflow is simple: Write or paste your draft on the left. Review the formatted result in the live preview. Copy the rich content in one click. Paste it into Confluence. It preserves useful structure such as headings, lists, tables, links, emphasis, and common PRD-style sections. You can also export the result as HTML or Markdown. Three input modes Different drafts need different parsing rules, so the editor includes three modes: Auto recognizes common document patterns automatically. Markdown renders Markdown structures directly. Plain Text turns rough notes, numbered sections, and tabular text into a cleaner document layout. This is useful when a draft comes from a text file, a writing tool, meeting notes, a spreadsheet, or an existing wiki page. A two-way documentation workflow The tool is not limited to publishing new drafts. You can also paste rich content copied from Confluence and convert it back into editable structured text. That creates a practical loop: draft in text or Markdown preview as rich content publish to Confluence bring later edits back into a local draft export to Markdown when needed Private by design The editor runs locally in your browser. There is no installation, and document content does not need to be uploaded to a server. That makes it useful for internal product documents where teams want a lightweight formatting tool without adding another docume

DeepSeek released its own agent harness this August. It crossed 66k stars in about a day (yes, sir!) and went over 200k by early September. That is already pretty crazy for something that is still a developer preview. But while researching this post, I found something much more interesting. DeepSeek Harness actually uses Pi's model layer to connect to models outside DeepSeek. Yep. The new agent runtime from DeepSeek uses Pi under the hood for part of its model support. And Tianyi Cui , who leads the Harness project, has publicly said Pi is a favourite daily driver for many people at DeepSeek. Lol. That makes this comparison way more fun because they agree on quite a lot. Both think the harness matters, both are open source, both let you change a lot of the runtime, and both try to avoid locking you into one model. But they take the idea in very different directions. Pi gives you a tiny coding agent with four tools and lets you build from there. DeepSeek Harness gives you a full agent runtime where even the agent loop itself can be swapped. This is going to be an interesting one. Stick to it! TL;DR Category Pi DeepSeek Harness Winner Real tool use in our eval 21/30 passed 20/30 passed Pi Cost per shared success $0.031 $0.028 DeepSeek Harness Median time per task 362.9s 252.1s DeepSeek Harness Avg runtime tokens in our run 924,990 88,562, with a catch DeepSeek Harness Simplicity Four main tools and a tiny prompt Much larger runtime with 53 built in tools Pi Deep runtime control Powerful TypeScript extensions around a small core Even the agent loop can be replaced DeepSeek Harness Model support 25+ providers and very easy switching Broad support, partly through Pi's model layer Pi Local models Ollama, vLLM, and custom providers are well supported Possible, but needs more setup Pi Sandbox None in the core Three built in sandbox modes DeepSeek Harness Session inspection Very readable session tree Full append only trajectory and replay DeepSeek Harness Daily use Very smal

阿富今天在交易日誌裡留下的所有痕跡，集中在早上八點四十五分五十八秒到八點四十六分四十二秒之間，四十四秒。 那四十四秒他做得很紮實。查帳戶、查 00919 跟加權指數的報價、查實驗進度、查委託簿、拉日 K，然後寫下一份完整的盤前策略。隔夜美股道瓊跌 1.18%、費半漲 1.30%、台積電 ADR 約漲 3%，中東衝突升溫、布蘭特油價逼近 100 美元，台指期夜盤幾乎平盤。他給加權指數 up、信心 0.55，給 00919 flat、信心 0.40。決策是核心續抱，不換倉、不新倉、不因為帳面有賺就停利。 裡面有一條特別值得看：停損線 32.06，算式他寫得很清楚，昨收 32.71 乘以 0.98。 這條線他前天就答應要設了 D20 收盤後他自己列了隔天要做的三件事，第一件就是重設 00919 的停損，當時算出來大約 32.25。然後 D21 他整天沒出現，三件事一件都沒做。 今天這條線回來了，數字從 32.25 變成 32.06。算法很單純，拿最近一次收盤價乘 0.98，前天代進去是 32.25，今天代 32.71 進去就是 32.06。這條規則不需要記得中間漏掉的那一天，它只是重跑一次公式。 這是這種 agent 蠻有意思的一個性質。它的紀律不放在腦袋裡，放在一個叫 working_state 的外部欄位，每天早上重新代入當天的數字算一遍。人會因為前一天累壞了而忘記設停損，它不會。 代價在另一邊。今天這份盤前策略從頭到尾沒有一個字提到昨天。沒有「昨天我沒來」，沒有「D20 那三件事我一件也沒做」，沒有「這條線晚了一天才補上」。他其實有讀到價格層面的連續性，策略裡就寫著 00919「已連兩日回落」。價格他查得到，因為價格在資料庫裡；自己缺席一天他查不到，因為那不在任何一個他會去查的欄位。 帳本是連續的，對自己的敘述有一個洞。 計畫的後半段沒有執行 那份策略最後一段列了三件要盯的事：00919 有沒有跌破 32.06、加權指數是不是真的撐得住、下午兩點結算兩筆預測。 十點半，排程照常啟動，日誌裡沒有任何一筆巡檢紀錄。十二點半，同樣的事再發生一次。像 D19 那種正常運作的日子，這兩個時點各會留下幾百字的觀察，價格、離停損線多遠、有沒有在途委託、當日虧損熔斷線碰到沒有，全部對一遍。今天是空的。我寫到下午兩點半為止，盤後復盤跟那兩筆預測的結算也還沒進來。 寫計畫幾乎不花力氣，守計畫才花。他這兩天做到的是前面那個。 市場又剛好放過他 00919 開 32.68、最高 32.77、最低 32.47、收 32.58，比昨天跌 0.13 元，跌幅 0.40%。全天最低點離 32.06 那條停損線還有 1.28%，沒有任何一刻需要有人在旁邊做決定。跟 D21 一樣，今天沒事的原因是市場沒動，跟有沒有人盯盤無關。 加權指數收 47,183.36，比昨天的 47,105.78 漲 77.58 點，0.16%。他押 up，方向對了。不過盤中一度衝到 47,548.26，漲幅 0.94%，收盤把七成多的漲幅還了回去，這段起伏正好落在他寫著要盯的那個問題上，而他不在。00919 那筆 flat 要不要算命中，得看容忍區間怎麼畫，日誌到現在也沒有結算紀錄，我不替他打分。 帳戶收在券商可動用 1,089 加持股市值 1,172，總資產 2,261。對本金 2,000 是加 13.05%，對八月十二日的起始工作現金 2,200 是加 2.77%。昨天 2,266，今天少了 5 塊。最後一次成交還停在 8 月 14 日的 D4，22 減 4，18 個交易日沒有下過單。 我在意的是哪一段 三十個交易日的實驗剩八天，翻倍這件事從 D10 講到現在早就沒有討論價值，今天不重講。 真正在被測試的是另一件事：一個沒有人盯著的 agent，能不能把自己早上寫的東西執行到收盤。D21 他連計畫都沒寫；今天他寫了，寫得比很多人類完整，然後在開盤的四個半小時裡完全不在場。 四十四秒的紀律，跟四個半小時的紀律，不是同一種東西。 本系列文章 我讓一個 AI 拿 2000 塊台幣去股市，目標 30 天翻倍，這是第 0 天 怎麼用一套開源系統，把 LLM 逼近世界模型（實驗技術篇） 想自己跟著養一隻會操盤的 AI?從安裝 DuDuClaw 桌面版開始 D1：真金白銀第一天，唯一一筆單被退回來 D1 番外：一筆下錯的單，被 AI 說成「只是測試」 把 AI 操盤手搬下 Windows：換一套能跨平台的券商 API D2：錢第一次真的進了市場，阿富卻兩次認不出自己下的單 D3：一天之內，三條停損線 D4：線畫在 262，它真的砍了：阿富第一次停損出場 D5：沒下單的一天，帳本卻出了兩次包 D6：連續兩天零下單，但校準報告說他的方向判斷跟丟硬幣沒兩樣 D7：他昨晚幫今天寫好三條規則，今天早上一條

When Managing AI Conversations Becomes More Work Than Using AI AI is supposed to reduce busywork. But after using AI seriously for a while, I noticed something strange: I was creating a new kind of busywork just to manage my AI conversations. A useful answer appears in ChatGPT. I copy it into Notion. Claude gives me a better explanation of an important decision. I copy that too. Another conversation contains something I might need later, so I create a page for it, give it a title, choose a folder, maybe add a tag, and promise myself I'll organize it properly someday. Eventually, the workflow starts looking like this: Do the work with AI → extract the useful parts → organize them somewhere else → try to find them again later. At that point, AI conversation management becomes a second job. The problem starts with a reasonable habit Saving useful AI outputs makes sense. If an AI conversation contains something valuable, you probably don't want it to disappear into a long list of old chats. So you create a system. Maybe it's Notion. Maybe it's Obsidian. Maybe it's a folder full of documents. The exact tool doesn't matter much. The process often becomes: Have a useful AI conversation Identify something worth keeping Copy it Create a page or note Give it a title Choose where it belongs Add tags or metadata Repeat None of these steps is particularly difficult. The problem is that they happen after almost every useful conversation. And as AI becomes part of more of your work, the amount of information worth saving grows quickly. More AI usage creates more organizational work Suppose I use AI for five different things during a project: exploring a product idea comparing possible approaches reviewing research challenging assumptions planning implementation I may end the day with several valuable conversations. But now I have another question: What should I do with all of them? If I save everything, my knowledge base fills up with material I'll probably never revisit. If I sav

Two executors on the main line, one on fixes, and a lead who only cuts, hands over and accepts. The moment the lead starts writing code, the facts stop being prepared - and the next batch of tasks costs more than the hour that got saved. 👋 I'm Anton - a software engineer working mostly in PHP/Symfony and Go, currently carving a live PHP monolith into Go services. The earlier parts of this series were about what a task must contain and how small it has to be cut. This one is about who does what once the cutting is a habit: the split of roles, and why the number of live executors is capped. Notes: github.com/brilliant-almazov . Maybe you run this better, maybe you'd draw the line somewhere else. Either way it's one arrangement on one codebase, not advice for yours. The thesis The lead doesn't write code. Not "shouldn't, mostly". Doesn't. The moment the lead starts writing code, the facts stop being prepared - and the next batch of tasks goes out with holes in it. That costs more than the hour of typing that got saved. The chain Five steps, and the lead owns all five: Prepare the facts. Exact paths, full type signatures, values, the acceptance command. This is the only place in the whole process where reading the code is allowed. Hand over. The executor gets the task whole, in one message. Accept the iteration - by its own package, one command, nothing else. Accept the stage - the full pass, exactly once, at the end. Close the executors. One that has finished is closed straight away. Then, once the set is closed, one more thing that isn't part of the loop: the audit of the set . It comes after step five, not instead of it. 1 2 3 4 5 ┌──────────┐ ┌────────┐ ┌────────────┐ ┌────────────┐ ┌──────────┐ │ prepare │─▶│ hand │─▶│ accept the │─▶│ accept the │─▶│ close │ │ the facts│ │ over │ │ iteration │ │ stage │ │ executors│ └──────────┘ └────────┘ └────────────┘ └────────────┘ └──────────┘ the only its own one full pass place reading package, at the end, the code is one co

Every RAXXO tool ships under strict semantic versioning, major.minor.patch, and I never break that pattern even for a tiny fix A patch bump means nothing changed except a bug going away, a minor bump means something new showed up without breaking anything old, a major bump is a promise I rarely make The one time I skipped the discipline, a silent breaking change went out labeled as a patch and it cost me a support thread I could have avoided entirely The changelog and the version number are the same commitment written twice, and skipping either one breaks trust faster than any bug does Why a Solo Studio Even Needs This It would be easy to assume version numbers matter for teams, not for one person shipping small tools. I thought that too, before I had five live products and a support inbox that made it obvious how wrong that assumption was. A customer who bought a RAXXO tool eight months ago and only opens it twice a year has no idea what changed in between. The version number is the only honest answer I can give them without writing a personal message to every single user, and it has to be an answer that means the same thing every time. Semantic versioning gives me that consistency for free, as long as I actually follow it instead of treating it as decoration. The rule is simple to state: a patch release changes nothing except fixing something broken, a minor release adds capability without removing or altering anything that already worked, and a major release is allowed to break things, on purpose, with warning. The value is not in the rule itself, plenty of solo developers know the rule. The value is in never being tempted to shortcut it because a change feels small in the moment. I've written before about the changelog habit that keeps every RAXXO tool honest , and version numbers are the other half of that same commitment. A changelog entry without a version number attached to it is just a diary. A version number without a changelog entry explaining it is just

One of those questions that looks like it should have a one-click answer and does not. Here is exactly what Confluence Cloud can and cannot do with numbers, and how to pick between the three ways out. Short answer. A normal Confluence table cannot add anything up: there is no formula engine behind it, and the number on the page is whatever somebody typed. A Confluence database can show a total at the bottom of a field, including Sum and Average. Neither can calculate a value per row, so nothing in Confluence Cloud gives you a column that multiplies price by quantity. You have three ways out, and the right one depends on how often the numbers change. What Confluence actually does It is worth separating two things that look similar on a page, because the answer is different for each. Tables The classic table you get from the editor is a layout element. It stores text, numbers, links and macros in cells, it merges cells, it sorts columns for the reader. It does not compute. There is no cell reference, no formula bar, nothing that recalculates when a value changes. If a total sits in the bottom row, a person put it there, and it stays wrong until a person notices. This is not an oversight anyone forgot about. The request to add spreadsheet behaviour to Confluence tables is one of the older open items in Atlassian's public tracker, and it is still open. Databases Databases are the newer structured-data feature, and they do calculate, within limits. Each field can show a calculation at the bottom, and for number fields the list is genuinely useful: Field type Calculations available Number Sum, Average, Min, Max, Count values, Count unique values, Count empty, Percent empty Everything else Count values, Count unique values, Count empty, Percent empty The calculation can be saved as part of a view, so the total is there for the next reader rather than something each person switches on. Worth knowing before you plan around them: databases are not available in the Atlassian G

A short visual brief paired with a screenshot helps an AI assistant understand the exact webpage or interface element you want to change. A screenshot paired with a short note gives an AI assistant the visual context it needs to adjust a webpage or interface. You open your site on your phone and notice the header navigation feels cramped. The text is readable, but the spacing looks tight and the buttons blend into each other. You want the assistant to adjust it, but describing the problem in words takes several tries. By the third prompt you are writing a paragraph about padding and alignment. A single screenshot and a one-sentence note would have been faster. Screenshots give an AI coding assistant immediate visual context. The assistant can see the current layout, the size relationships between elements, the color contrast, and the exact part of the interface you want to improve. A short written note alongside the image explains what should change and what should stay the same. Together, the two pieces let the assistant make the right edit without guessing. What Screenshots Show and What They Miss A screenshot captures the visible state of a page at one moment. The assistant sees how text lines up, where images sit, how buttons look next to each other, and whether content fits comfortably or crowds the edges. The image reveals small details that are easy to forget when writing a description—a dropdown menu that sits slightly off from the field next to it, a border color that does not match the rest of the page, or a footer that floats too high on short pages. A screenshot captures the visible state of a page, revealing layout, spacing, color, alignment, and the size of elements relative to each other. A screenshot also helps the assistant tell similar elements apart. If your page has three different button styles, the image shows which one appears in the section you want to edit. If you have multiple menus, the screenshot clarifies whether you mean the bar across

AI made it possible for me to run more tasks in parallel, but I became worse at focusing on any one of them. Here is why the existing trainers did not work for me and what I decided to build myself. If you want to see what I ended up with first, try my trainer . How Multitasking Became a Problem In my work, I constantly switch between different tasks and often work in multitasking mode. Strangely enough, AI tools have only made this problem worse for me: they allow me to run more processes in parallel, making it even harder to keep my attention on a single task. Why Dual N-Back? I began looking for exercises that could help me train my working memory and concentration. That is how I discovered Dual N-Back and started reading the research around it. The results of these studies are mixed, so I did not treat the method as a magical way to increase intelligence. I simply wanted to find a regular and measurable exercise and test it through my own experience. Why Existing Trainers Did Not Work for Me I then explored the existing trainers. Each of them had interesting ideas, but none completely satisfied me. Some had interfaces I did not like, some used scoring systems that were difficult to understand, and others lacked adaptive difficulty, an offline mode, or the ability to train without creating an account. In the end, I decided to build my own trainer: Dual N-Back App trainer Try the current version of Dual N-Back for free and without signing up . What I Built and What Is Still Ahead I combined the things that were personally important to me: a calm, modern interface, clear performance metrics, adaptive difficulty, a local training history, and the ability to use the trainer without mandatory registration. The trainer is currently completely free, supports multiple languages, and its core features are available without an internet connection. Training results are stored locally on the device. I am also working separately on optional synchronization between devices. I

Allostatik gives you a working relationship with your AI that compounds — each session builds on the last instead of resetting with every conversation. It's a folder of plain files you own, plus the routines that keep them true. AI can hand one person the leverage that used to take a team — but only when it's integral to how you work. It has to see how you work, what you've decided, where things stand, and carry that across time; every decision it can't see, it will happily contradict. Out of the box it can't carry any of it in a form you control. Every window opens from zero, or from a summary you never wrote: you re-establish your preferences, re-derive your patterns, re-explain what you're building. Every time. If that cycle is familiar, this is for you, specifically — not for someone evaluating AI, for someone already deep in it. You've probably built the fix once already: a rules file. A CLAUDE.md , a Cursor rules file, a filled-in Project Instructions field. The instinct is exactly right — context you author, in plain text, where you can read every line. Now look at yours. It still says something you stopped believing three weeks ago. It's been steering every session since, and nothing told you. That's a config file: written once, wrong quietly. Nothing checks it for freshness, and it has no way to tell you a rule went wrong — a bad rule doesn't announce itself, it gets enforced, agreeably, until you notice the work bending. Allostatik is that rules file, grown into a control system, with you as the gate on every change. The rest of this is why that shape. Even the context you keep is being edited Resets are only half of it. Long conversations get compacted — a polite word for summarized by something that wasn't in the room when the decision was made. That edit you never see at all. Memory features synthesize what to keep about you — those you can read and prune, but you didn't write them, and neither editor asked what mattered. Call it the invisible hand: an

I Used Every AI Coding Assistant I Could Find for a Month. Here's What I Actually Pay For Now Note: this is the fourth post in an ongoing series where our small editorial team tests AI tools in real workflows and writes down what we find. No affiliate links. No "sponsored by" disclaimers to hide. We pay for the tools we review, including this month's experiment, which cost us about $190 in subscriptions and a fair amount of patience. The setup I spent most of August and September doing the same two jobs across eight AI coding tools: building a small internal dashboard (React + a Node API) and maintaining an older Python service at work. Same tasks, same files, same me. The tools were GitHub Copilot, Cursor, Codeium, Tabnine, Replit AI, v0, Bolt, and Lovable. Why those eight? Because those are the ones people actually argue about in our developer group chats — and the ones a colleague keeps asking me to "just try already." I also wanted to answer one question that none of the marketing pages answer: what happens after the first week, when the novelty wears off and the tool has to earn its place in a daily workflow? Quick background so you know where I'm coming from: I'm a working developer, not a journalist. Ten years mostly backend, some frontend when I have to. I'm skeptical of anything that promises to write my code for me, and I've been burned before by autocomplete that produces confident nonsense. The short version If you only take one thing from this: Copilot is still the safest default, Cursor is the most capable if you'll actually use its chat properly, and the no-code app builders (Bolt, Lovable, v0) are not for me — but they're genuinely impressive for people who don't live in an IDE. Everything below is the longer version with the boring details, including the stuff that surprised me. GitHub Copilot: the boring, reliable choice I started with Copilot because it's what most of my team already had. The completions are fast and mostly invisible — which is th

The code is being produced faster than I can confidently review, validate, and ship it. Old workflow vs. new workflow The biggest change in my workflow is not simply that AI writes code faster. It is that my role is gradually moving away from manually implementing every detail and toward designing, orchestrating, reviewing, and validating the overall result . That sounds like a small shift, but it changes where I spend most of my engineering effort. Coding is no longer the slowest part Working with coding agents has changed how I think about development productivity. I can define a task, let an agent explore the codebase, implement the change, add tests, and return a working diff much faster than I could build everything manually. But implementation is only one stage of software delivery. flowchart LR A[Requirement] --> B[Design] --> C[Implementation] --> D[Review] --> E[Test] --> F[Deploy] AI can compress the implementation stage dramatically, but review, testing, integration, security, and deployment still have their own limits. When those stages cannot keep up, faster coding does not remove the bottleneck. It simply moves it downstream. This is also the point Red Hat recently raised in Why faster coding isn't making delivery any faster : generating code and delivering reliable software are not the same thing. I have started to notice this more clearly in my own workflow. An agent can produce a fairly large change while I am still building the mental model needed to judge whether that change is actually good. More code is not the same as more productivity Suppose I used to complete two meaningful changes in a day and AI now helps me produce six. Calling that a 3x productivity increase sounds reasonable at first, but only if the rest of the engineering system can absorb those six changes. They still need to be understood, reviewed, tested, integrated, and eventually operated in production. If review capacity or CI becomes the constraint, I have not created three ti

If you have ever built a timesheet, you have probably run into the same problem twice: clock times are easy for humans to read, but payroll systems want durations as decimal hours. A shift from 09:00 to 17:30 is not 9.5 on a timesheet. It is 8.00 hours if you subtract a 30-minute lunch, and payroll usually wants that written as 8.00 , not 8:00 . In this article, we’ll walk through the Excel formulas, the edge cases, and the small time-math mistakes that cause real payroll problems. 1. Clock time and duration are not the same thing Before touching Excel, separate two ideas: Clock time answers “when did this happen?” Examples: 09:00 , 17:30 , 22:00 Duration answers “how long did it last?” Examples: 8 hours , 7.5 hours , 8.25 hours A timesheet usually starts with clock times, but payroll needs durations. That means you have to convert: 09:00 → 17:30 into: 8.00 decimal hours Once the duration is a decimal number, payroll can multiply it by an hourly rate. 2. The core Excel formula If Excel stores your start and end times correctly, the basic formula is: =(End - Start) * 24 Why multiply by 24? Because Excel represents time as a fraction of a day: 06:00 = 0.25 days 12:00 = 0.50 days 18:00 = 0.75 days Multiplying by 24 converts that fraction into hours. Example A B C Start End Hours 09:00 17:30 8.00 In C2 : =(B2-A2)*24 Result: 8.00 Make sure the result cell is formatted as a number, not as time. 3. Subtract an unpaid lunch break If the shift has an unpaid lunch, subtract it before multiplying by 24. Suppose: Start: 09:00 End: 17:30 Unpaid lunch: 30 minutes If lunch minutes are stored in D2 : =((B2-A2)*24) - (D2/60) Or if lunch is stored as 0:30 : =((B2-A2)-D2)*24 For this example: 17:30 - 09:00 = 8:00 8:00 - 0:30 = 7:30 7:30 = 7.50 decimal hours So the payroll value is: 7.50 Not 7.30 . 4. Why 7.30 is wrong This is the mistake that causes the most confusion. If you worked 7 hours 30 minutes, the decimal version is not 7.30 . It is: 7 + (30 ÷ 60) = 7 + 0.50 = 7.50 decimal ho

Haven't you ever wondered if this AI vibe coding has made us lazy? Who's been solving problems on LeetCode lately? 😅 I've noticed that accepting is easier than thinking, by a margin so small that no single accept feels like anything, and it adds up anyway. Part of why it's hard to notice is that it feels faster even when it isn't. But I've come to think "lazy" is the right worry aimed at the wrong thing. There are two kinds of lazy and only one of them is a problem. I'm going to go into a little background here, because I didn't come up with this, and I didn't reach this conclusion on my own. Lazy is why we have compilers Larry Wall, who created Perl, put laziness first on his list of the three great virtues of a programmer , and his definition is the whole argument: "the quality that makes you go to great effort to reduce overall energy expenditure." Great effort. Good lazy isn't the absence of work, it's work moved somewhere better, and it's more or less why compilers exist (somebody got tired of writing the same assembly by hand and decided, reasonably, that the machine could do that part) and why every abstraction we lean on all day is really someone's laziness done properly. Handing that kind of toil to a model is nothing new. The config I've written a hundred times and the regex I could write but would rather not and the Dockerfile I could recite and the test scaffolding that comes out identical in every project I've ever started: I understand all of it and I'm simply declining to type it again and I feel no guilt about that whatsoever (honestly I'd be more worried about a developer who insisted on typing all of it out by hand in 2026, on principle, one character at a time, while the rest of the team went home). That's not skipping the thinking. That's skipping the typing after the thinking was already done. The other kind skips the understanding The second kind of lazy offloads the understanding itself. The model writes the thing and it runs and the tests are

The video cover is what we are all feeling in this Job Market. I don't have a good cover image this...

“Store the data” is only the beginning of the problem. The difficult questions usually come afterward: What structure does this data actually have? Which fields are missing or inconsistent? Which values are invalid? Which changes are safe to apply automatically? What exactly changed after a repair? Can the system prove that its storage and indexes are still consistent? I built Atlas to answer those questions inside the database engine itself. Atlas is a zero-dependency embedded database for semi-structured data. It stores records, builds a full-text search index, infers schema, analyzes data quality, proposes safe repairs, preserves uncertain records, and records an audit trail of applied changes. It does not use SQLite or SQL. It is not intended to replace SQLite for relational workloads. Instead, Atlas focuses on a gap that is usually handled by external scripts and tools: Data inspection, diagnosis, and safe repair as first-class database capabilities. That is the problem Atlas was built to solve. Why data quality belongs inside the database engine Most databases are very good at storing and retrieving data. That is necessary, but real-world data work rarely stops there.** Operational records, imported JSON, CSV files, event payloads, and semi-structured documents often arrive with problems: { "id" : "T-1" , "title" : " Connection timeout " , "priority" : "HIGH" } { "id" : "T-1" , "title" : "connection timeout" , "priority" : "high" } { "id" : "T-2" , "title" : "Unicode café search" , "priority" : null } These records contain several potential issues: Duplicate logical identifiers Leading or trailing whitespace Inconsistent capitalization Null-like values Missing fields Mixed data types Malformed email addresses Different date formats Inconsistent structures across records A storage engine can preserve these values perfectly while still leaving the data difficult to understand and use. The usual response is to add external tools: A schema profiler A data-quality

If you've ever lost 20 minutes at 2 AM debugging a submask enumeration loop, or drawn a segment tree on paper for the fifth time this month, this post is for you. I want to share a collection of 31 free, browser-based tools built specifically for competitive programming — no signup, no installs, code stays client-side. They're grouped at Utility Tools Lab's Competitive Programming category , and they cover almost every "I wish there was a tool for this" moment from contest practice. Here's a tour of what's inside. Visualizing structures you normally only imagine Half the pain in CP isn't the algorithm — it's seeing what your data structure is actually doing. Graph Visualizer — paste a CP-style edge list and get a force-directed graph you can drag around. Toggle directed/undirected and 0/1-indexing, then copy the adjacency list back out. Segment Tree Builder — feed in an array, pick sum/min/max/gcd, and watch the tree render, plus grab a full C++ class template. Sparse Table Builder — visualizes every level of the O(1) RMQ precomputation, with live queries. Union-Find (DSU) Visualizer — watch path compression and union-by-rank happen live on a forest view. Path Finder — paint walls on a grid and run BFS to see the shortest path animate, then copy the grid as a C++ 2D vector. Sieve Visualizer — step through the Sieve of Eratosthenes on a color-coded grid. Sorting Visualizer and Binary Search Visualizer — step-by-step animations with live comparison counts, or lo/hi/mid tracking on your own array. These aren't just "nice to look at" — watching the not-found path in binary search, or the moment a submask loop wraps around, is often exactly where off-by-one bugs hide. Code generators that skip the boilerplate Some things in CP are conceptually simple but easy to typo under time pressure. These tools generate ready-to-paste C++: Bitmask Planner — set N ≤ 12, visualize all 2^N states and submask iteration order, get a DP skeleton. PBDS Generator — Order Statistics Tree boi

Messy modules rarely break because a pure helper returns the wrong integer on a tidy fixture. They break because three functions share a temporary CSV path, an environment flag, and a cache nobody named. A coding agent then proposes a cleanup that deletes dead branches, renames locals, and still satisfies every existing assertion. The next production export fails because the implicit file layout moved while the return payload stayed identical. That failure mode is the reason this workflow exists, and it is not a style problem. The first commit should freeze a ledger of hidden couplings and store a hash beside it. Only after that hash is in source control should you allow one structural change. The cleanup is legitimate only when the recorded hash remains identical. Cleanup diffs fail differently than feature diffs Feature work usually changes an observable on purpose, so reviewers know which assertions must move. Cleanup work is sold as behavior-preserving, which trains people to trust deletions and rename-only hunks. Coding agents amplify that bias because they optimize for shorter files, conventional names, and green unit tests. Reviewers then accept large deletions that would look suspicious inside a feature pull request. Return-value tests are the wrong gate for that class of change. The public function can still return {"ok": true, "rows": 12} while the working directory quietly shifts. Downstream jobs that glob files or catch a named exception will fail after merge. Those hidden couplings remain part of the contract even when no unit test mentions them. Build a side-effect ledger instead of another unit test Treat the messy module as a black box that emits more than a return value. A ledger is a canonical JSONL file with one record per fixture and fully sorted keys. Side-effect entries need stable ordering so the serialized bytes stay deterministic across reruns. The SHA-256 digest of that file is the only number that must remain constant. Each record should c