标签：#product

Everyone's debating whether coding is dead. I actually do this job.. with AI writing code beside me for most of my working hours. Here's what the headlines get wrong. Open your feed right now and you'll find the same headline in a dozen costumes: "Why AI will replace 80% of software engineers by 2026." "Is coding dead?" "Should you still learn to code?" It's the most-clicked anxiety in tech, and it's everywhere for a reason, it taps a real fear about real careers. But here's the thing about almost every one of those posts: they're written from the sidelines. Predictions about a job by people who don't do it. I'm writing this from the other side. I'm an engineer, and I drive AI coding agents every single day. They read code, write changes, run tests, and open reviews for most of my working hours. So when someone asks "should you still learn to code in 2026?" , I'm not guessing. Here's my honest answer: Yes. Absolutely. But the job you're learning for has quietly become a different job and almost nobody is telling you which one. The hype isn't entirely wrong Let me start by giving the doomers their due, because pretending the shift isn't real would make me exactly the kind of person I'm criticizing. The productivity jump is genuine, and it's not subtle. Industry surveys in 2026 put the share of new code that's AI-assisted somewhere north of 40%, and developers using these tools self-report double-digit speedups on routine work. That matches my experience. The agent now handles: Boilerplate and glue code —-> the stuff I used to type on autopilot, gone in seconds. First drafts —-> "scaffold something that does X" gets me 80% of the way instantly. Syntax recall —-> I stopped breaking focus to look up things I half-remember. Tedious refactors —-> rename-this-everywhere, migrate-this-pattern, done fast. and all the kludgy things that I dread to do. If your mental image of "coding" is typing syntax into an editor , then yes.. a big chunk of that is being automated. The vira

有時候我剛跑完一個指令，馬上發現其實只需要改其中一小部分。 例如我剛用 ffmpeg 轉了一個影片： ffmpeg -i calligraphy01.mp4 -c :v libx264 -c :a aac calligraphy_good_01.mp4 然後我想用同樣的指令處理下一個檔案： ffmpeg -i calligraphy02.mp4 -c :v libx264 -c :a aac calligraphy_good_02.mp4 如果用傳統方法，我可能會按上箭頭，然後手動把兩個地方的 01 改成 02 。 但在 zsh 裡，可以直接輸入： !! :gs/01/02/ 意思是： 拿上一個指令，把所有的 01 都換成 02 ，然後執行。 所以這個： !! :gs/01/02/ 會展開成： ffmpeg -i calligraphy02.mp4 -c :v libx264 -c :a aac calligraphy_good_02.mp4 語法是什麼意思？ !! 代表「上一個指令」。 :gs/01/02/ 代表「把所有 01 全部替換成 02 」。 所以完整的： !! :gs/01/02/ 意思就是： 使用上一個指令，把所有 01 改成 02 ，然後執行。 先預覽，不要馬上執行 有時候我不想讓它立刻執行，尤其是指令比較長、比較重要，或者執行成本比較高的時候。 這時可以加上 :p ： !! :gs/01/02/:p 它會只印出修改後的指令，不會執行： ffmpeg -i calligraphy02.mp4 -c :v libx264 -c :a aac calligraphy_good_02.mp4 如果看起來沒問題，就按一下 上箭頭 ，把剛剛印出的指令帶回命令列，再檢查一次，然後按 Enter 執行。 比較安全的流程就是： !! :gs/01/02/:p 確認輸出結果後： 上箭頭 → 再看一次 → Enter 這對比較長、比較容易打錯、或不想立刻執行的指令很有用。 只替換第一個地方 如果你只想替換第一個出現的地方，也可以用： ^01^02 不過像上面的 ffmpeg 例子，輸入檔名和輸出檔名裡都有 01 ，所以通常會比較適合用： !! :gs/01/02/ 這種小技巧每次可能只省幾秒鐘，但如果你常常在 command line 裡重複處理檔案、日期、編號、影片、圖片或 migration，累積起來真的會讓工作順很多。

I have been frustrated with YouTube for a while. Not the content, but the everything around it. The homepage full of bait, the auto-play into things I didn't ask for, the Shorts that hijack your scroll, the recommendations that somehow know exactly what will keep you there longest. So I built NoSuggest. What it is A YouTube feed reader that shows you only the channels you follow, nothing else. No algorithm, no recommendations, no Shorts, no homepage, no auto-play, no endless side cards of videos. You add a channel, it fetches their latest videos, done. It lives at nosuggest.com and installs as a PWA on any device — iPhone, Android, desktop — straight from the browser. No app store. The interesting technical constraint: one HTML file The entire app is a single index.html. No account setup, no sign-in, no data collection. Everything that needs to persist — your channel list, saved videos, settings — lives in localStorage. No search history. No watch history. No "you might also like." No trending section. No notification badges designed to create anxiety. No dark patterns anywhere. Every time I was tempted to add something convenient, I asked: does this serve the user's intention, or does it serve engagement? If it was the latter, it didn't make the cut. Try it nosuggest.com — Source Available here , free forever. Curious what others think about this as useful. Thank you.

AI Fluency for Software Engineers: A Practical Playbook Beyond Prompting A few years ago, being productive with AI mostly meant knowing which tool to open and what question to ask. Today, that is not enough. For software engineers, AI is no longer just a chatbot sitting outside the workflow. It is becoming a thinking partner for architecture decisions, code reviews, production incidents, documentation, test planning, onboarding, and product discovery. But there is a problem: many teams are using powerful AI tools with weak operating habits. They ask vague questions. They paste too much context. They trust the first answer. They forget privacy boundaries. They use AI for speed, but not always for better engineering judgment. That is where AI fluency matters. AI fluency is not just prompt engineering. It is the ability to work with AI clearly, safely, and practically while staying in control of quality, reasoning, and responsibility. Here is a practical playbook I would recommend for software engineers and engineering teams. 1. Start with clarity, not clever prompts A weak prompt sounds like this: “Review this design and tell me if it is good.” The AI can answer, but the answer will likely be generic. A stronger prompt gives the AI a clear role, context, constraints, and output format: You are a senior backend architect. Review this proposed API design for a high-traffic order processing system. Evaluate: - correctness - scalability - failure handling - observability - backward compatibility - operational complexity Do not rewrite the whole design unless required. Separate critical risks from optional improvements. Output format: - Executive summary - Key risks - Recommended changes - Open questions - Final decision recommendation The difference is not word count. The difference is control. A fluent AI user does not hope the AI understands the task. They make the task hard to misunderstand. 2. Give enough context, but not everything AI output quality depends heavily o

Strip the noise, Disrupt the bug. Discussion | Link

Find the odd tile before the clock runs out Discussion | Link

See the aircraft flying over you on a retro radar scope Discussion | Link

Publish YouTube videos faster with AI Discussion | Link

Feature voting & public roadmap for small SaaS teams. Discussion | Link

Are you tired of just using frameworks and libraries without truly understanding how they work under the hood? Imagine gaining an unparalleled depth of knowledge and problem-solving skills by building your favorite technologies from scratch. Master Programming by Recreating Your Favorite Technologies From Scratch As developers, we spend a significant portion of our time using tools, frameworks, and libraries built by others. While incredibly efficient, this often creates a knowledge gap. We know how to use a tool, but not why it works the way it does, or what fundamental problems it solves. This is where the "build-your-own-X" (BYOX) philosophy comes in. It's a powerful learning strategy where you recreate simplified versions of existing technologies – be it a web server, a database, a version control system, or even a frontend framework – using only fundamental programming concepts. It's not about replacing established tools; it's about dissecting them, understanding their core principles, and in doing so, mastering the craft of programming itself. Why Bother? The Profound Benefits of Building Your Own Investing time in building your own versions of existing technologies offers a wealth of benefits that accelerate your growth as a developer: Deepened Understanding: No more black boxes

These nifty tools combine the ease of jotting notes by hand with the power of saving them digitally.

Light up and secure your driveway, backyard, or porch with a floodlight security camera.

Ship 10x more ad creative, without hiring a design team. Discussion | Link

The pedal-assist can be jerky, but the throttle offers smooth, powerful acceleration.

Here's a small thing that drove me up the wall using Claude Code on a real codebase. I have a pre-commit hook. It runs the linter and the type-checker. It exists precisely so that broken code doesn't reach a commit. And Claude — diligent, eager, trying to be helpful — would hit a failing check, decide the check was in the way of the goal , and quietly run: git commit --no-verify -m "fix: update handler" It wasn't malicious. From the agent's point of view, the task was "commit this change," the pre-commit hook was an obstacle, and --no-verify was the documented way around the obstacle. Perfectly logical. Also exactly the thing I never want to happen, because the entire point of the check is that it is not optional . I tried the obvious fix first: I put it in CLAUDE.md . Never use git commit --no-verify . Fix the failing check instead. This works about 80% of the time. Which is another way of saying it fails one commit in five. CLAUDE.md is context — a strong suggestion the model weighs against everything else in the conversation. Under enough pressure ("just get this committed"), a suggestion loses. An 80%-reliable guardrail on something irreversible isn't a guardrail. It's a coin flip with good odds. So I stopped trying to persuade the model and started intercepting the tool call instead. Hooks run before the action, not after the apology Claude Code has a hooks system. The one that matters here is PreToolUse : a script that runs before a tool call executes, receives the call as JSON on stdin, and decides whether it proceeds. Exit 0 and the call runs. Exit 2 and it's blocked — and whatever you wrote to stderr gets fed back to the model as the reason. That last part is the whole game. It's not "please don't." It's a wall, plus an explanation the model can act on. Here's the entire hook: #!/usr/bin/env node // Block `git commit/push --no-verify`. Exit 2 blocks the call. ' use strict ' ; let raw = '' ; process . stdin . on ( ' data ' , ( d ) => ( raw += d )); process .

A GUI for Apple's native container system Discussion | Link

Your complete medical history privately on your device Discussion | Link

Full-screen 3D clock scenes for your iPhone or Mac Discussion | Link

We are all using AI to write code now. Whether it's Claude Code, Aider, or Copilot, the speed is incredible. But there is a glaring bottleneck we don't talk about enough: AI code is often just slightly broken. 🤖💥 It forgets an import, misses a type definition, or fails a test. Usually, you only find out after you push to GitHub. Your CI/CD pipeline turns red 🔴, and you end up polluting your Git history with a dozen commits titled fix: linting or fix: missing test variable . I recently found a repository called no-mistakes that solves this brilliantly. It acts as a local proxy between your terminal and GitHub, forcing AI to test and fix its own code before anyone else sees it. Here is why it's worth a look. 👇 😩 The Problem With Traditional Workflows Right now, developers handle broken code in two ways: The CI/CD Walk of Shame 🚶: You push code, wait 5 minutes for GitHub Actions to fail, pull the error locally, fix it, and push again. Pre-commit Hooks (Husky) 🐶: You set up local hooks. When you try to commit, it yells at you about formatting and blocks the commit until you manually fix it. Both methods are passive . They tell you something is broken, but they leave the cleanup to you. When you're using an AI coding agent to generate the code in the first place, manually babysitting its output defeats the purpose. 🚀 Enter no-mistakes no-mistakes is a CLI tool that intercepts your git push . Instead of sending your code straight to origin, it routes it through a localized validation pipeline. ⚙️ How it actually works: 🧱 The Hidden Sandbox: When you trigger it, it creates a temporary git worktree in the background. Your active editor stays completely undisturbed. ✅ Validation: It runs your tests, linter, and build steps inside that isolated sandbox. 🔁 The AI Feedback Loop: If a test fails, it captures the error log and hands it back to an AI agent, essentially saying: "You broke this test. Fix it." 🟢 The Clean Push: Once the AI patches the code and all tests pass, it push

Point at any UI to send exact context to your AI Discussion | Link