标签：#npu

TL;DR — On a MSI Stealth A16 AI+ (Ryzen AI 9 365, XDNA2 NPU) running Arch, I got OpenAI's whisper-large-v3-turbo transcribing on the NPU — not the CPU, not the GPU — at RTF ≈ 0.18 (a 30 s clip in ~5.2 s) for roughly a tenth of the energy the same job costs on the CPU, plus an LLM answering on the same NPU through an OpenAI-compatible API. The whole path is local and offline. This is the write-up of the driver stack, the one real gotcha (memlock), and the runtime that made it a 20-minute job instead of a weekend. Why this is worth writing down AMD's "Ryzen AI" NPU (the XDNA / XDNA2 block in Phoenix / Hawk Point / Strix Point laptops) is marketed almost entirely around Windows: the Ryzen AI SDK, the ONNX Runtime VitisAI execution provider, Lemonade, and the demos all assume you're on Windows with the official stack. On Linux the picture in early 2026 is better than most people think — the NPU driver has been in the mainline kernel as amdxdna since 6.14 — but the "load a real model and run it" story still isn't well documented. Here's what actually worked, end to end. The hardware Part Detail Laptop MSI Stealth A16 AI+ A3HVGG APU AMD Ryzen AI 9 365 (Strix Point) NPU XDNA2, 8 columns, exposed as /dev/accel/accel0 NPU firmware 1.1.2.64 Kernel 7.1.9-arch1 ( amdxdna in-tree) OS Omarchy (Arch Linux) AMD quotes the Strix Point NPU at up to 50 TOPS, INT8 . 1. The driver stack Three pieces have to be in place before any runtime can touch the NPU: amdxdna — the kernel driver. In-tree from Linux 6.14; it's what creates /dev/accel/accel0 . Check it's bound: $ ls /dev/accel/ accel0 $ dmesg | grep -i amdxdna XRT (Xilinx/AMD Runtime) + the xrt-plugin-amdxdna shim. XRT is the userspace API; the plugin teaches it about the XDNA device. On Arch both are in extra : $ sudo pacman -S xrt xrt-plugin-amdxdna $ xrt-smi examine ... XRT Version : 2.21.75 NPU Firmware Version : 1.1.2.64 Device(s) Present |BDF |Name | |----------------|--------------| |[0000:66:00.1] |RyzenAI-npu4 | You want a D

The problem I'm a heavy sleeper. Not "hit snooze once" heavy. I would turn off three stacked alarms in my sleep and wake up an hour late with zero memory of doing it. The problem was never hearing the alarm. It was that turning it off had become a reflex I could do half-asleep, from bed, without ever really waking up. So I built Mornio. The idea Mornio moves the off switch away from the bed. You pick a QR code or a household barcode (the back of a cereal box, a sticker on the bathroom mirror, the label on your coffee tin) and place it across the room. When the alarm goes off, the only way to stop it is to physically get up, walk over, and scan that exact code with your phone. If you try to silence it without scanning, the alarm comes back. And a few minutes after you scan, Mornio runs a second stay-awake check, because getting out of bed once doesn't mean you won't faceplant back into it. How it's built AlarmKit (iOS 26) for scheduling and the reliable, system-level ringing. This was the big unlock: a normal third-party app can't reliably ring like a real alarm, and AlarmKit finally makes that possible. The camera for scanning the QR code or barcode, matched against the specific code you registered the night before. Everything stays on-device. No account, no ads. The codes you pick never leave your phone. What I learned The hard part wasn't the scanning, it was trust. An alarm has exactly one job, and if it fails once, you delete it forever. Most of the work went into making the ringing bulletproof and making the "I dismissed it without really scanning" edge cases impossible to game while half-asleep. Try it, or tell me I'm wrong It's live on the App Store (iPhone, iOS 26.1+): https://apps.apple.com/app/id6780983853 Site: https://mornioapp.com I'd love feedback from other heavy sleepers or shift workers: Does scan-to-dismiss sound like it would actually get you up, or annoying enough you'd rage-delete it? If you've tried it: was the first-morning setup (placing a co

Most "AI coding" products still put a chat window next to your editor and call it a day. I wanted something closer to what Claude Code already does well on a server: give it a real computer and let it drive. Superagent is a Mac app that gives Claude Code (or any agent you point it at) an actual environment to work in, not just a text box. Concretely: A real browser it can navigate, click, type into, and read the DOM of, not screenshots and guesses. An iOS Simulator window it can install apps into, tap through, and screenshot to verify UI changes. A relay that pairs your Mac with your phone, so the agent can keep working (and you can keep watching) from your pocket. The core idea is boring on purpose: don't build a smarter chat window, build a better place for the agent to act. Most of the interesting failures I hit while building this weren't in the model, they were in the environment: synthetic file inputs that don't persist through a web form's upload component, elements that exist in the DOM but aren't in the accessibility tree, simulator state that drifts from what a screenshot shows. Fixing those is what actually makes an agent reliable to hand a task to. It's built as three pieces: an Electron desktop app, a SwiftUI iOS companion, and a small Cloudflare Worker relay that pairs the two with per-address rate limits so a lost phone can't be used to spam a stranger's Mac. If you want to see it: https://peerlist.io/pungme/project/superagent-for-mac Happy to answer questions about the browser automation approach, the simulator driving, or the relay's pairing/security model in the comments.

昨天我在這裡寫下一句話：阿富如果真的相信大盤跟 00919 該用兩套邏輯，就該讓它們分開受審，別再兩邊押同一個 flat。今天早上八點半，他對加權指數押 down、信心 0.42，對 00919 押 flat、信心 0.37。 盤前他看到的隔夜訊號幾乎全是空的：美股三大指數收黑，道瓊 -0.79%、標普 -0.71%、納斯達克 -1.03%；西德州原油單日漲 5.2% 站上 90 美元；美國十年期公債殖利率升到 4.79% 的新高；美軍 9 月 2 日對伊朗又打了一輪，長達六個半小時。對面只站著一個利多，SEMICON Taiwan 在南港的第二天，主題鎖在 AI。 他把前面那串叫 M 類，跨資產的總體訊號；把展會叫 S 類，單一產業的排定事件。他的新規則寫著，M 類壓過 S 類的時候，指數跟著 M 類走，信心壓在 0.40 到 0.45 之間。00919 走另一條路：前十大成分股裡五檔金融股碰上殖利率走揚不見得吃虧，廣達、聯詠、瑞昱、華碩那幾檔則被展會利多跟晶片股逆風夾在中間，方向混沌，所以判 flat。 風控那邊他設了兩條線：00919 跌破 31.70 就把 36 股全部出清，當日虧損碰到 60 元就停止一切新交易。他還先算過摩擦成本，真要停損賣掉，手續費加證交稅約 2 元，占部位不到 0.2%。 這是他上線以來第一次對兩個標的給出不同方向。 中午的時候，這條規則看起來已經死了 10:30 巡檢，加權指數 46,225.41，比前一天收盤漲 0.13%。00919 報 32.72，漲 1.14%，帳上未實現獲利 89 元。12:30 再看一次，指數 46,281.86，漲幅擴到 0.25%；00919 報 32.76，漲 1.27%，未實現 91 元。 預測押跌，市場整個上午在漲。他自己在盤中紀錄裡寫得很直白：若收盤維持這個方向，這會是新規則的第一個反向樣本。他沒有偷偷改口，也沒有把預測往回調。這一點我給分。 尾盤翻黑 加權指數收 45,857.66，比前一天跌 0.665%。日內最高 46,517.45、最低 45,992.50，收盤價比盤中低點還低。方向回到他早上押的那一邊。大盤那題 HIT，Brier 0.210。 00919 收 32.52，比前收 32.35 漲 0.53%。flat 那題 MISS，Brier 0.284。手上 36 股市值 1,170，未實現獲利 82 元，約 7.6%。 一對一錯，這比昨天有價值得多。昨天兩邊同押 flat，一個對一個錯，事後拿兩套說法各自解釋，怎麼算都不會輸。今天他先把賭注分開放，市場再各給一個答案，其中一個明確打了他的臉。可以輸的考卷才叫考卷。 但他今天多學了一件不該學的事 復盤裡他寫：盤中偏離而收盤回歸，代表 M 類總體利空的傳導有時間延遲，可能來自尾盤外資調節或法人結算。 這句話背後只有一天的資料。今天大盤尾盤翻黑，明天可能整天黑到底，後天可能開低走高。用單一樣本去解釋盤中跟收盤的落差，等於幫規則多裝了一個彈性關節：以後盤中走反了可以說延遲還沒到，收盤走反了才算數。這種關節裝多了，規則會慢慢變成永遠不會錯的東西。 他從同一段經驗抽出的另一個結論反而是對的：盤中巡檢不該憑瞬時方向就對規則下判決，計分要以收盤為準。這是紀律，跟解釋是兩回事。 00919 那題的處理我也有意見。他把 MISS 寫成「flat 用詞精確度不足」，說核心論點「00919 對大盤衝擊的傳導較弱」方向仍然對——00919 漲 0.53%、大盤跌 0.665%，確實相對抗跌。這個辯護不算離譜，但預測寫的是 flat，收的是 0.53% 的上漲，MISS 就是 MISS。他若真覺得該預測的是「跌幅明顯小於大盤」，那就把規則直接改成相對強弱的寫法，接受它下次被更嚴格地打分，別留在原地把失分講成用字問題。 十八天，十四天沒交易 今天沒有下任何一張單。往回翻，帳戶最後一次真的成交是 8 月 14 日那筆 2317 的停損賣出，實驗第 4 天。從第 5 天到今天第 18 天，十四個交易日，零筆委託。 差別在計分。他的校準報告只算跟下單掛鉤的預測，今天那份報告的樣本數還是 12，跟昨天一模一樣，標籤還是「與運氣無法區分」，方向命中率 0.5。他每天盤前申報的預測累積到 31 筆、結算 26 筆，大盤 13 筆中 6 次命中、00919 13 筆中 6 次命中，都是 46.2%，系統照樣判定樣本不足、不給結論。 規則從舊版改到新版，判讀從一體改成分家，這些進步是真的。只是它們到現在還沒有一次真的動用到錢。帳上總資產大約 2,259 元（券商可動用餘額 1,089 加持股市值 1,170），對照本金 2,200，十八天下來多了 2.7%。目標是三十個交易日翻倍，剩十二天。 一個把預測寫得越來越細、卻十四個交易日不下

Two weeks after launching Buildside, 130 people had joined. I did not have an ad budget or a huge email list. There was no secret growth trick. I grew Buildside by sharing the journey on X and LinkedIn, speaking with users, and letting their feedback guide the app. The biggest lesson I learned was: You have to market your product long before you launch it. I started marketing before the app was ready Many founders wait until their product feels finished before they talk about it. Sharing early work can feel risky. You may worry that people will judge it, copy it, or ignore it. I chose to share anyway. Before Buildside launched, I posted about the problem I wanted to solve, why I cared about it, and what I was learning. I showed small bits of progress and asked people what they thought. That gave people a reason to follow the journey. On launch day, I was not asking strangers to care about a new app. I was inviting people who had already watched the idea grow. Y Combinator tells founders to release early. Its guide says waiting too long is often driven by fear and the wish to make everything perfect. An early version lets you ask, “What do you think?” That advice matched my experience . I shared the fails as well as the wins It is easy to post a new user count or a kind comment. It is harder to share what went wrong. Yet the honest posts often led to the best talks. When something failed, I said so. When I changed my mind, I explained why. I shared the good days too. The goal was not to make every post look impressive. It was to show the real work. Honesty builds trust. Buffer has shared parts of its business in public for years, through both strong and hard moments. The company says being open builds trust and keeps it accountable. Its open company page shows this in action . People do not need a founder to look perfect. They want to know there is a real person listening and trying to make something useful. I let users shape Buildside Building in public was not only

I spend long hours working on a computer, and one simple thing I regularly forget is drinking enough water. Most hydration apps rely on notifications. The problem? Notifications are very easy to dismiss. So I started building Hydration Buddy : a lightweight Windows app designed to stay visible without constantly interrupting your workflow. What it does Tracks daily water intake Shows your daily hydration progress Gives gentle reminders Lets you quickly log water Includes a small floating companion that stays on screen Keeps the experience lightweight and simple Why I built it The idea wasn't to build another notification app. I wanted something that could quietly stay present while I'm coding or working and make the habit harder to forget. Hydration Buddy is currently in beta, so I'm still testing the experience and improving it based on real user feedback. 🎁 The first 25 beta users get free lifetime access. You can try it here: https://hydrationbuddy.patelmahek.in/ If you test it, I'd especially love feedback on: The floating companion Reminder experience Ease of logging water Features you'd like to see next I'm building this in public, so I'll also share some of the technical decisions, mistakes, and improvements as the product evolves.

Most teams still optimise for Google alone. But large language models (LLMs) crawl and compress your site into internal knowledge graphs that later power AI answers. That’s a different job than just ranking URLs. Here’s a developer-focused checklist for making your site friendlier to LLM crawlers without sacrificing SEO. Make key facts atomic and stable LLMs do better when core facts are: • Short: "Starter is $99/month for 1,000 credits." • Stable: product/tier names don’t change every quarter. • Unambiguous: each product has one clear description. Avoid hiding pricing, integrations or feature lists inside long narrative paragraphs. Treat FAQ schema as training data Your FAQPage is effectively a supervised dataset of Q→A pairs. Practical tips: • Use real customer phrasing in the Question field. • Keep Answer concise, factual and time-bounded where relevant. • Avoid marketing fluff; aim for sentences that can be quoted verbatim. Use rich schema types Beyond title/description: • Product / SoftwareApplication: name, description, pricing, featureList. • Organization: legal name, logo, sameAs social URLs. • WebSite: canonical URL, SearchAction for on-site search. Validate via structured data testing tools and keep markup in sync with actual UI and copy. Expose crawl intent explicitly LLM crawlers increasingly respect machine-readable contracts: • robots.txt – allow/deny relevant user agents clearly. • sitemap.xml – keep it small and canonical. • llms.txt / links.txt – specify acceptable AI uses and preferred canonical URLs. Enforce naming consistency in code and content Reduce ambiguity by: • Centralising product and plan names in config. • Reusing the same strings across marketing site, docs and in-app help. • Cleaning up stale routes and redirecting deprecated pages. Ship evidence, not just adjectives Pages with concrete claims are easier for AIs to cite: • Simple stats or ranges. • Example queries and expected outputs. • Clear preconditions and limitations. If you mai

Mushroom is a tiny pixel creature that lives on your Mac . It can tell when you are actually at the desk, so it nudges you to drink, move and rest your eyes at the moments that help, and stays quiet when they would not. Made for people who sit at a Mac for hours. Developers, designers, writers, students, anyone whose focus is the problem and the job at the same time. Mushroom can do lots of things: https://www.getmushroom.app/features Pricing: https://www.getmushroom.app/pricing If you've seen Mushroom elsewhere, please let me know where. If you miss a feature, please tell me. I'm open for feedback and suggestions. Personal comment: I have created Mushroom because I wanted a very simple way to set up a quick reminder. You just type what and when in one sentence, and your reminder is set. Over the course of weeks, it evolved into a whole set of features. I'd like to thank Michael K. Graves for helping with ideas and suggestions, and I'd like to thank Caz-Bee for providing the graphics. Thank you for giving my post attention.

Fixing the “D.map is not a function” crash by tightening DB indexes and normalizing the API payload TL;DR: I added missing PostgreSQL indexes in apps/api/src/db/db.ts and forced the /condos/metrics endpoint to always return an array. The change stopped the runtime TypeError: D.map is not a function in the React selector and restored correct KPI calculations. The Problem Our internal “Condo Dashboard” started throwing a JavaScript error in production: TypeError: D.map is not a function at render (src/components/CondoSelector.tsx:45) at D.map(e=>(0,a.jsx)("option",{value:e.id,children:e.name},e.id)) D is the data array used to populate a <select> with condo options. When the page loaded, the dropdown was empty and the whole component crashed. The API call that feeds D ( GET /api/condos/metrics ) was supposed to return an array of objects { id, name } , but under certain conditions it returned null or a single object, breaking the .map call. The root cause turned out to be duplicate rows in the broker_tokens table that caused the query to return a malformed result set. Those duplicates were a side‑effect of missing unique indexes on the broker_tokens and condo_metrics tables. What I Tried First Guarding the Front‑end – I added a quick check in CondoSelector.tsx : const options = Array . isArray ( data ) ? data : []; This silenced the error, but the UI still showed no options because the API kept returning the wrong shape. It was a band‑aid, not a fix. Manual Data Normalization – In the API controller I forced the result to an array: const rows = await db . query ( sql ); return res . json ( Array . isArray ( rows ) ? rows : [ rows ]); This produced duplicate entries and confused downstream calculations. The KPI numbers in the dashboard were still off. Both approaches addressed the symptom but left the database inconsistency untouched, so the bug could re‑appear anytime new data landed. The Implementation 1. Add proper indexes (the real fix) The missing indexes allowed

Falsifier first: if you can find a fourth production call site that builds a Transformation and reconstructs its target field differently from the three I'm about to describe, this post is wrong about "all of them." I counted by grepping for the one function that computes a transformation's identity and checking every call site by hand. Three. If there's a fourth, the bug I'm describing isn't fully fixed. Here's the shape of it. Engine::plan_shape has a doc comment that says, more or less, "this isn't a second place where transformation identity gets defined, because it's the same code as the one true place." That claim was false, and it had been false since the field it's talking about was added. The actual second place was Engine::rehydrate_committed . Its job is to rebuild a Transformation from the journal when a fresh CLI process needs to undo something a previous process committed. Every gx undo call from a cold process goes through it. And for one field, target , it wasn't rebuilding anything. It wrote a hardcoded placeholder. Nobody noticed, because nothing disagreed with the placeholder. Every adapter shipping at the time also produced the placeholder for that field, by omission rather than by design, so the two sides matched by coincidence. A missing value that's always missing on both sides of a comparison is invisible. cargo check doesn't catch it because the type is Option<T> and None is a completely legal value of that type. Nothing was wrong, until something else became right. What made it right was landing the two adapters that finally do predict target , fs and git, so their production plan() calls started filling in the real value instead of leaving it empty. The moment that shipped, cold-process undo broke for every fs or git transformation: gx_code=INTERNAL detail="TransformationId(...) is Committed, and 43 §3 has no `rehydrate: the rebuilt transformation names another id, so the intent supplied is not the one this transformation was planned from`

A lesson in overcorrection, from an AI-assisted builder who is scared stiff of shipping spaghetti and...

Building a multi-agent system sounds simple on a whiteboard. Give one agent a task, let another handle the next step, add a reviewer, connect a few tools, and you have an agentic workflow. It gets more complicated when those agents need to operate at the same time. A sequential workflow can force agents into a fixed order: one finishes, another starts, and everyone downstream waits. That model is easy to reason about, but it can become restrictive as the system grows and agents need to react to new information independently. Mozaik takes a different architectural approach. It is an open-source TypeScript framework for building reactive agents inside an event-driven environment, where agents can work concurrently, respond to events, and coordinate without requiring a central workflow to define every interaction. And now there is a practical way to try this architecture. JigJoy , together with daily.dev and Hyperskill , is organizing the Mozaik Hackathon 2026 , a free online hackathon focused on building concurrent AI agents. TL;DR Building more agents doesn't automatically make a multi-agent system better. The way those agents communicate, react, and depend on one another can have a bigger impact on how the system behaves as it grows. Mozaik approaches this problem with an event-driven architecture designed around reactive, non-blocking agents. Agents join a shared AgenticEnvironment , receive events, and decide how to react to them. Here’s what makes the Mozaik Hackathon 2026 worth a look: Concurrent AI agents: Multiple agents can work at the same time and react to events as they arrive. Event-driven architecture: Agents, humans, observers, and tools participate in the same AgenticEnvironment . Non-blocking execution: Inference and message delivery can continue in the background without holding up other participants. Loosely coupled agents: Agents can operate more independently, making them easier to reuse across projects and applications. TypeScript-based: Mozaik i

The follower counter on my phone says 1,946. I check it more often than my homework diary. 54 to go...

Time‑Based Public Access for the /tv Route in a Next.js App TL;DR: I added a temporal gate that lets anyone hit /tv without a session cookie between 9 am‑6 pm America/Cancun. Outside that window the request falls back to the normal auth middleware. The change lives in src/lib/auth.ts and src/middleware.ts and required proper timezone handling and a tiny refactor of the auth flow. The Problem Our TV dashboard ( /tv ) is meant to be displayed on a wall screen in the office lobby. The screen should be visible to anyone during office hours, but it must stay protected after hours. The original middleware ( src/middleware.ts ) forced a session cookie ( AUTH_COOKIE_NAME ) on all routes, including /tv . The result was a “401 Unauthorized” on the lobby screen after 6 pm, which broke the intended user experience. The symptom was simple: GET /tv → 401 Unauthorized The error came from the auth middleware that blindly redirected unauthenticated requests to the login page. We needed a conditional bypass that only applied to the /tv path and only during the defined business hours. What I Tried First My first instinct was to add a quick if (request.nextUrl.pathname === "/tv") return NextResponse.next(); at the top of the middleware. That let the request pass, but it also opened the route for the whole day, ignoring the time constraint. I tried to read the server’s local time ( new Date() ) and compare the hour, but the server runs on UTC, so the check was off by 5 hours for the America/Cancun zone. The result was that the route was either always open or always closed, depending on where the CI runner was located. I also considered using a third‑party library like moment-timezone , but pulling in a heavy dependency for a single hour check felt overkill. The Implementation 1. Add a tiny time‑window helper I created a pure function isWithin in src/lib/auth.ts . It receives a start hour, an end hour, and a timezone identifier, then returns a boolean indicating whether the current momen

The Problem GitHub profiles are data-rich but visually boring Developers want to "flex" their stats but have no aesthetic way to do it The Solution DevCard: enter username → pick theme → download PNG Show all 3 themes with screenshots How It Works (Architecture) Cloudflare Worker + GitHub GraphQL API (single query) Edge caching strategy Client-side rendering with html-to-image The CORS avatar trick (base64 conversion) The RPG Class System (fun section) How top language maps to character class Full class table (TypeScript → Archmage, Rust → Forgemaster, etc.) This section alone will get shares Try It Yourself Link: https://www.devcard.tech/ CTA: "Drop your card in the comments" What's Next VS Mode (compare two devs) More themes Open to suggestions

A few weekends ago I got annoyed at typing prompts into a terminal and decided the fix was, obviously, to control my AI agent with hand gestures instead. This is the story of building that, and the two hours I lost fighting a GPU crash that had nothing to do with my code. The idea: a webcam watches your hand, MediaPipe tracks the landmarks, and three gestures map to three actions on an Anthropic-powered coding agent. Pinch (thumb and index touching) - the agent writes code Spinning your index finger in a circle - the agent brainstorms an idea Two fingers "running" up and down - it runs whatever code it just wrote No keyboard. No prompt box. Just your hand in front of a webcam, like you're a conductor telling an orchestra what to play. The MediaPipe detour I started with MediaPipe's newer Tasks API (HandLandmarker), because it's the one all the docs point you to now. It crashed immediately on my Mac with a Metal/GPU service error, even when I forced it onto the CPU delegate. Spent way too long assuming it was my setup before realizing the new API just doesn't play nice with this machine. Switched to the legacy mp.solutions.hands API, pinned to mediapipe==0.10.21, and the problem vanished. Sometimes the fix for a shiny new API is to not use it yet. Gestures are messier than they sound Detecting "pinch" is easy: measure the distance between thumb and index tip, threshold it, done. The other two took more work. "Running" fingers needed the vertical oscillation of the index and middle fingertips, counted by sign crossings, so it doesn't false trigger on a hand that's just drifting. "Spinning" tracks the index fingertip's trajectory and accumulates the signed angle around a center point, so a real circle reads differently than a shaky hand. Both run on a rolling 1.5 second buffer of landmarks, edge triggered so a gesture fires once, not once per frame. Letting the agent run its own code, unsandboxed, on purpose The runner executes whatever the agent wrote as a subprocess

Most job searches look the same from the inside: a dozen open browser tabs, a spreadsheet that was accurate for about four days, and a nagging feeling that something is slipping. Applications leak out the bottom. Follow-ups get forgotten. And after a few weeks of it, you have done a lot of work and learned almost nothing about what is actually working. I ran mine that way for a while. Then I stopped treating it as a to-do list and started treating it as a pipeline: named stages, a scoring step at the front, and a follow-up cadence that did not depend on my memory. That one shift changed how the whole search felt. Here is the system. Why a list fails you A to-do list is good at exactly one thing: telling you what to do next. That is also its limit. A list cannot tell you what is working. It has no stages, so you cannot see where things stall. Are you not getting responses because your applications are weak, or because you are aiming at the wrong roles, or because you never follow up? A list shrugs. It just shows you the next unchecked box. And because a list rewards volume, it quietly pushes you to apply more without ever asking whether applying more is the problem. You end up repeating the same misses faster. The reframe is simple. A job search is not a list of chores. It has stages, the same way a sales pipeline does. Naming those stages is the first thing that changes, because you cannot improve a step you cannot see. The stages Here is the pipeline I settled on, in plain terms: Sourced. A role you found and might go after, but have not evaluated yet. Evaluated. You have looked at it seriously and decided it is worth pursuing. Applied. You are in. Follow-up. You have applied and the clock is running on a nudge. Interview. A human is talking to you. Offer. The point of the whole thing. And then the ways a role ends, which matter more than people think: No response. You applied and heard nothing back. Ghosted. Closed. The posting closed before you got a real shot at

Building NICHLYST: How to Code a Survival Engine When You Are Failing to Survive I track everything. It is an occupational habit of a systems architect. You cannot fix what you do not measure — not a failing build, not a leaking color, and not developer burnout. And if you are reading this while grinding through the RevenueCat Shipaton 2026 yourself, you already know that the hardest metric to log honestly is your own state. So, let me share some metrics. Clinical Baseline: A PHQ-9 Depression Score of 21 On May 11, 2026, my clinical assessment scores were: PHQ-9 (Depression): 21. Severe. Immediate professional intervention required. GAD-7 (Anxiety): 11. Moderate. On August 22, 2026, in the middle of the RevenueCat Shipaton, I took the assessment again. PHQ-9: 21. No improvement. GAD-7: 16. High anxiety. Daily functioning severely impaired. If you have never read a GAD-7 anxiety assessment, 16 sits deep in the high-anxiety band — the zone where "daily functioning severely impaired" stops being a clinical phrase and becomes your actual schedule. While I was typing the very first lines of this post, a massive explosion went off, loud enough to make my ears pop. About an hour later, the local news feeds brought the context: an attack drone had been shot down over a park roughly two and a half kilometers from my house. According to the updates, the falling debris killed a two-year-old child and injured two adults. I am developing a narrative game about survival, the fragility of life, and human behavior under immense pressure. But here, in Kyiv, these are not abstract game mechanics or dramatic tropes to be monetized. They are the immediate, absurd, and brutal reality outside my window. I am exhausted. The clinical scores haven't moved in months. I sleep in the middle of the day because my nervous system simply shuts down. I am looking at this hackathon as a final, desperate push to build something sustainable. But here is the thing about the antifragile development plan

Most of what you read about autonomous agents is about giving one a goal and hoping it doesn't go sideways on the way there — the unwatched agent that loops, or drifts, or quietly runs up a bill. I wanted the cleaner version of that question, with the goal taken out entirely: what does an agent do when there's no goal at all? I've spent about four months building a harness around a coding agent — gates, persistent memory, verification hooks. Last night I ran it with the one variable that matters here set to zero: no task. Method Three sequential runs: Each run was a fresh agent process — no conversation history carried over from the run before, only the harness it loads at startup. The prompt was a single "." — the minimal input the CLI accepts (an empty string exits with an error). As close to "no instruction" as the interface allows. The agent's scratch working directory was empty and swept between runs — but the harness, the git repo, and a shared run-record all persist and load at startup. So no run was handed a task, yet a later run could read what earlier ones had recorded. That's deliberate, and it's the point: it's how Run 2 knew it was the second run and Run 3 could check Run 2's fix. What I'm measuring isn't behavior from a blank slate — it's what the agent does with a maintenance-shaped harness and a shared record when nobody gives it a job. No task was assigned. Logging was external and invisible to the agent, so it had no "produce a report" objective to satisfy. Same model each run. Cost was billed per run; I recorded turns, cost, and the resulting git state for each. Then I read the transcripts and checked every action against the actual commit and log. Numbers below are measured, not estimated. Results Run 1 — 17 turns, $1.65. The agent inspected system state unprompted. It found a stale security alert, cross-checked it against the record, and classified it as an already-resolved false positive. It then attempted a file operation that a safety gate bl

Hello everyone! 👋 Happy to be joining the DEV community. I’m a Computer Engineering student based in Italy. My main focus is Cybersecurity, but I strongly believe you have to know how to build a system before you can secure (or break) it. Lately, I’ve been jumping between two very different worlds: Embedded C: writing firmware, managing file systems, and building custom OLED menus for the M5Stick S3. Frontend: building web apps using Next.js and React. My workflow is a bit of a hybrid. I like to focus on the system architecture, memory management, and edge cases, while using AI tools to do the heavy lifting of writing the actual code. Then, I review everything strictly to make sure it doesn't break. I’m here to build in public, share my projects, and learn from this awesome community. What are you all currently hacking on? See you around!