标签：#Product

TL;DR: I set up a Claude Code skill that checks in with me about my workday, asks follow-up questions, and saves a structured markdown file I can use as promotion evidence. Here's why it works, and how to build one in about five minutes. May 6th On May 6th I had an energy level of 2 out of 5. I got my Claude Certified Architect exam score back that day: 717 out of 1000. I needed 720. I missed it by three points. Four lines down in the same entry, my manager had told me: "your leadership is being felt around Artium. You're making a good impact." Here's the thing about that day: the bad number is vivid and self-evident. 717. Three points short. That number was going to live in my head rent-free for weeks. But the recognition? That quietly evaporates. Left to memory, May 6th is the day I failed the exam by three points. On the page, it's also the day my manager told me my leadership was landing across the company. The entry keeps the thing I'd lose otherwise. The Problem With Memory I've been bad at this for years. At performance review time, I'd stare at a blank document trying to remember what I'd actually done. I'd come up with four things instead of forty. My manager would advocate for me based on what she happened to see, which was never the full picture. The thing is, I did good work. I just didn't capture it. A few years ago I tried to solve this with Google Forms , a structured form I'd fill out at the end of each day that fed into a spreadsheet. It worked, kind of. The data was there, but it felt like homework. The form didn't ask follow-up questions. It didn't notice when I was being vague. I had to go somewhere specific to fill it out. And when review time came, I had to go back somewhere else to compile everything, figure out what mattered, and assemble it into something coherent. The friction wasn't just the daily entry. It was the whole chain: capture, retrieve, synthesize, present. I was on my own at every step. So I built something better. What I Built

Structured output broke on us three times. The third time taught us what "operator-ready" means. Last quarter we shipped a contract-extraction agent to an enterprise legal team. Schema validation passing at 97%. Human reviewers satisfied with the output quality in testing. Rollout went smoothly. Then it broke. Three times. In three completely different ways. The first two failures we fixed with better prompts and stricter schemas. The third one taught us something the first two hadn't: that "operator-ready" is not a technical checklist. It's a claim about your agent's behavior under conditions you didn't design it for. Failure one: the validation paradox Week two. A lease agreement came through with a renewal clause formatted as a table instead of prose. Our extractor looked for renewal terms in a specific JSON path. The table format populated the schema differently. Validation passed. The extracted renewal date was off by two years. The fix was obvious in retrospect: add a canonical-format normalization step before extraction. But the lesson was sharper than that. Schema validation tells you the shape of the output, not whether the content is correct. A JSON object with the right keys and the right types can still contain wrong values. Our 97% validation success rate was measuring the wrong thing. It was measuring structure conformance, not content accuracy. After this failure, we separated validation into two signals: schema validity (does the object have the required fields) and field confidence (do we have evidence the content is correct). We started logging both. An output is trusted only when both signals are above threshold. Failure two: the retry loop that lies Month one. A particular clause type appeared in a contract format we hadn't trained our test set on. The extractor failed schema validation on the first attempt. Our retry logic kicked in, filled missing fields with model-inferred defaults, and passed validation on the third try. The output looked rig

Talk to GitHub Copilot out loud Discussion | Link

An AI agent that reproduces GitHub issues for you Discussion | Link

Every sprint starts with optimism. The board is clean, the story points are perfectly balanced, and the team is ready to ship. Then, Tuesday happens. The CEO wants a "quick favor." A major client finds a critical bug in production. The marketing team urgently needs a landing page tweak. By Thursday, your pristine sprint board is buried under a mountain of "urgent" tickets that were never discussed in planning. This is Unplanned Work , and it is the silent killer of engineering velocity. Why Unplanned Work is So Dangerous It’s not just that unplanned work takes time. The real damage comes from context switching . When a developer is deeply focused on building a new feature, forcing them to stop, spin up a local environment for a different repository, debug a legacy issue, and then try to return to their original task destroys their flow state. A "10-minute quick fix" actually costs the company an hour of lost productivity. When this happens multiple times a week: Deadlines Slip: The tasks you actually committed to get pushed back. Burnout Increases: Developers feel like they are working hard but accomplishing nothing. Trust Erodes: Management wonders why the team can't stick to a timeline. How to Protect Your Team You cannot eliminate unplanned work completely. Bugs will happen, and production will break. But you can manage it. 1. The "Firefighter" Rotation Instead of letting unplanned work disrupt the entire team, assign one developer per sprint to be the "Firefighter" (or Batman/Support). Their only job for that sprint is to handle urgent bugs, ad-hoc requests, and unblock others. The rest of the team is completely shielded. 2. The 20% Buffer Rule If you have 100 hours of developer capacity, never plan 100 hours of feature work. Always leave a 20% buffer specifically for unplanned tasks. If no fires start, you can pull from the backlog. If fires do start, your deadline isn't destroyed. 3. Track the "Ghost" Tickets The worst kind of unplanned work is the kind that h

Every week I was burning the same hours doing the same thing: opening tabs, copying data, pasting it into a spreadsheet and starting over. The work was mindless. It was repetitive. It was exactly the kind of task that shouldn't require a human being in 2024. So I built an n8n scraper workflow that now handles all of it automatically — and here's exactly how I did it. The Problem Worth Automating Keeping product data current is non-negotiable for tech content research. Specs change. Prices shift overnight. Availability fluctuates without warning. Before automation, that meant manually visiting product pages and logging updates into a tracking sheet — a process that consumed three to five hours every single week. The inefficiency compounded fast. I missed updates between check-ins. Formatting stayed inconsistent across entries. The cognitive overhead of context-switching between dozens of tabs left me mentally depleted before I even reached the analytical work. Data collection wasn't just slow — it actively degraded everything downstream. Something had to change. Why n8n and Not Something Else I evaluated several tools before committing. Zapier is polished but expensive at scale and frustratingly rigid with custom HTTP behavior. Make (formerly Integromat) offers more flexibility yet its pricing model penalizes heavy usage quickly. Python scripts give you full control but demand ongoing maintenance and provide no visual debugging environment for non-engineers. n8n threads the needle cleanly. It's open-source and fully self-hostable so there are no per-task fees regardless of volume. Its visual node editor makes workflow logic instantly readable. Its native HTTP Request node handles custom headers, authentication and response parsing without a line of external code. For a scraping workflow that needs to stay reliable, repeatable and maintainable — n8n was the clear answer. Building the Scraper — Step by Step Step 1 — Schedule the Trigger Every automated workflow needs a

Create your own Mac apps by chatting with AI Discussion | Link

Communities love your brand - Our AI team finds them for you Discussion | Link

A desktop pet that grows as you code with Claude Code Discussion | Link

Originally published on productize.life . Quick answer: pm-skills is a marketplace of around 68 Claude skills for product management across 9 plugins, from strategy and discovery to market research and AI shipping. It is built by Pawel Huryn, author of the Product Compass newsletter. Each skill is not a loose prompt but a named, sourced framework, and one of them audits the gap between documentation and code, a PM lens built for the era of AI-written code. Last week I was reading through a run of repos that pack product work into skills. Some pick one topic and go deep. This one does the opposite: it is the broadest of the bunch. It is called pm-skills, by Pawel Huryn, the author of the Product Compass newsletter. He packs almost the entire product management craft into around 68 skills across 9 plugins, from setting strategy, running discovery, and researching the market, to analyzing data, executing, and shipping software that AI wrote. Usually something this broad ends up shallow. But when I actually opened it, it was not, and one skill in particular made me stop and look for a while , because it covers an angle that only recently became necessary in the era where AI writes code for us. I will tell it in three parts, starting with what it is , then why it is not just a prompt box , and closing with lessons for anyone building products . Terms, gathered once, right here skill a ready-made set of instructions an AI agent (such as Claude Code) can invoke, like a shortcut that wraps one way of doing a task. framework a ready-made way of thinking from the PM world, such as SWOT, JTBD, or RICE, that you once had to read a book to use well. plugin (category) a group of skills that belong to the same topic, such as the discovery category or the go-to-market category. PRD a product spec document that says what will be built, for whom, and how success is measured. Part 1: What pm-skills is It is a marketplace of around 68 Claude skills for PM, organized into 9 plugins, eac

Originally published on productize.life . Quick answer: gstack is an open-source (MIT) skill set that Garry Tan, president of Y Combinator, builds with every day. It turns Claude Code into a team of 23 specialists, CEO, engineers, designers, QA, and a release engineer, forcing every change through a multi-lens review before shipping. The point is not speed; it is taste written into software. Last week I was going through a repo that collects skills for coding, several of them. Most share one theme: helping AI write code in a systematic way, and faster. But one made me stop longer than the rest, called gstack, for two reasons. One: its owner, Garry Tan, president and CEO of Y Combinator, took the stack he actually builds with every day and opened it for free. Two: it does not sell "code faster," it sells "review before you ship." Once I actually opened it, it was not just a toolbox but one of the clearest examples of an idea I have been interested in for a while. On the day AI can write code very fast, the bottleneck of the work is no longer speed. I will tell it in three parts, starting with what it is , then what gstack believes , and closing with lessons for people who build products, not just people who write code . Terms, gathered here in one place agentic coding letting an AI agent run the coding work in its own steps, from planning to writing to review to shipping, not just autocompleting a line at a time. skill a packaged set of instructions an AI agent (like Claude Code) can call, like a shortcut that wraps one way of doing one thing. review lens reviewing one piece of work from several roles, for example as a CEO, an engineer, a designer. taste the sense and judgment of what is good and what is bad, what to build and what not to ship. The part that is still human. Part 1: What gstack is Garry Tan describes gstack in the README plainly, as the way he works. "It turns Claude Code into a virtual engineering team: a CEO who rethinks the product, an eng manager

If you're anything like me, your Chrome toolbar probably looks like a collection of tiny puzzle pieces. Grammar checker. Screenshot tool. Summarizer. Writing assistant. Code explainer. Translator. Email helper. At one point I had more than a dozen extensions installed. Chrome became slower, pages loaded later, and every extension wanted permission to "read and change all your data." Then I started experimenting with AI tools instead. Not everything was better—but some things surprised me. Here's what I learned after replacing most of my browser extensions with AI. 1. Grammar Checkers I used to rely on grammar extensions that constantly underlined my writing. Now I simply paste my draft into an AI assistant and ask: Improve grammar while keeping my writing style. The biggest advantage isn't fixing mistakes—it's preserving tone. Traditional grammar tools often make everything sound the same. AI can make your writing cleaner without removing your personality. 2. Article Summarizers This was probably the easiest replacement. Instead of installing a summarizer extension, I paste the article and ask: Summarize in 5 bullet points Give me the key takeaways Explain it like I'm a beginner What important details are missing? The last prompt is especially useful because summaries sometimes leave out important context. 3. Code Explanation This has become one of my favorite AI use cases. Instead of searching Stack Overflow for every unfamiliar function, I simply paste the code and ask: Explain this line by line Why was this approach chosen? Is there a better alternative? What's the time complexity? The answers aren't always perfect, but they're often enough to understand what's happening before diving into documentation. 4. Writing Commit Messages This is something I didn't expect AI to help with. Instead of writing: fixed stuff I can paste my git diff and ask for a concise commit message. Example: feat: add JWT authentication middleware fix: resolve login redirect loop refactor:

👋 Hey dev.to community, Last week I shipped a workflow I built for a friend who runs an online shop. He called me again a few days later with a new headache: he's drowning in Purchase Orders. Every single one gets opened by hand, the data typed into a Google Sheet, and that sheet uploaded into his ERP to update his numbers. Hours a week, pure copy-paste. So I built him something to kill that step. He uploads the PO PDFs through a simple n8n form, and a structured Google Sheet comes out the other end. He just downloads it and pushes it to his ERP. How it's set up: The form accepts multiple PDFs at once , so he can batch a whole stack instead of doing them one by one. Each PO loops through on its own so nothing gets jumbled. The extraction runs on the easybits Extractor node ( @easybits/n8n-nodes-extractor ). I set the field structure up in two parts: the header fields that appear once per PO (PO number, PO date, delivery date, mark for, PR number, reference no), plus an articles array for the line items, each holding article name, unit and quantity. That array is the key bit, it gives you one entry per row of the PO table, and I flatten it into one sheet row per article with the header details repeated on each. Two things I added because real documents are messy: Error flagging . If any field comes back empty, the completion screen lists which document and which field didn't extract cleanly, so he knows exactly which PO to double-check instead of trusting it blindly. Document name column . The original filename lands in the sheet next to every row, so if a number looks off he can jump straight back to the source PDF. Workflow JSON is on GitHub: https://github.com/felix-sattler-easybits/n8n-workflows/blob/c38749a68fd6ea4ae6ebff41789d35cceaacdef1/easybits-purchase-order-extractor-workflow/easybits_purchase_order_extractor_workflow.json Anyone else automating document-to-sheet data entry? Curious how you're handling the messy multi-line rows – that was the trickiest par

The conversation around Agentic AI often focuses on one goal: making agents more autonomous. More tools. More reasoning. More planning. More independence. It sounds like progress. But is more autonomy always the right answer? As software engineers, we rarely optimize for "more." We don't build distributed systems when a monolith is sufficient. We don't introduce microservices because they're fashionable. We choose architectures that balance capability with complexity. The same principle applies to AI agents. The question isn't "How autonomous can my agent be?" It's "How autonomous should my agent be?" Autonomy Is a Design Decision When people talk about autonomy, they often think of it as a feature that an agent either has or doesn't have. In reality, autonomy is a design decision. Every time we allow an agent to make another decision on its own, we are increasing its responsibility. That responsibility comes with benefits, but it also introduces new engineering challenges. More autonomy means the agent can adapt to situations that weren't anticipated during development. It can make progress toward a goal without being guided through every step. At the same time, it becomes harder to predict, validate, debug, and trust. Autonomy isn't free. Thinking in Terms of an Autonomy Spectrum Instead of treating autonomy as a binary concept, it helps to think of it as a spectrum. At one end are systems that simply generate responses. They have no authority to take action. As autonomy increases, agents begin suggesting actions, invoking tools, planning multiple steps, and eventually deciding how to achieve a goal with minimal human involvement. The important observation is that every step along this spectrum increases both capability and complexity. That's why the objective shouldn't be to reach the highest level. It should be to stop at the level your problem actually requires. More Autonomy Isn't Always Better Imagine building an internal HR assistant. Its primary responsibil

When going abroad, the right plugs are essential to keep your gadgets charged. These are my favorite travel adapters and chargers.

A company shifted from project- to product-thinking after their platform outgrew single-team use. The limitations that they felt with their platform were one-off deliveries, lack of product vision, and weak feedback loops. They have moved toward a self-service, API-driven, multi-tenant infrastructure with clearer ownership and better abstractions. By Ben Linders

Replay QA tells you what is broken before your users do Discussion | Link

The Bublue BuVortex V5 ditches conventional skimming for a vortex-powered design that’s fascinating to watch, even if it’s severely impractical.

Move from opens to conversions Discussion | Link

I used to waste hours tweaking and re-tweaking my AI model prompts. It was like trying to find a needle in a haystack—I'd make a change, run the code, wait for the results, and then... nothing. The output would be inconsistent, unhelpful, or just plain wrong. I'd try again with tiny modifications, rinse and repeat, until I was about to pull my hair out. It wasn't until I stumbled upon the concept of reusable prompt templates that everything changed. It was like a switch had flipped—my code started producing consistent results, and I finally understood why. No more guesswork, no more frustration. Just good old-fashioned productivity. A simple shift from writing one-off prompt strings to using reusable templates is the key to reducing prompt overhead, increasing consistency, and getting back to doing what we love—building amazing, AI-driven applications. From Chaos to Control: A Simple Example Let's make this tangible. Imagine you're building a feature to generate a short story, but for different characters. Before: The Inconsistent, One-Off Way Without a template, you'd likely write a new prompt each time, introducing small, unintentional differences that lead to wildly different results. Two separate prompts = inconsistent, unpredictable output prompt_for_alex = "Write a short story about a character named Alex who is trying to get to work on time, but keeps getting delayed in a busy city." prompt_for_jordan = "Generate a story about someone named Jordan. They're late for work and stuck in traffic in a big city." See the problem? The tone, wording, and details are different. You have no control over the consistency of the output. After: The Clean, Templated Way Now, let's use a single template. We define the core structure once and simply pass in the parts that change. Now, let's use a single template. We define the core structure once and simply pass in the parts that change. One template = consistent, predictable output story_template = "Write a short story about