标签：#management

An accepted AI suggestion is an event, not a durable outcome. If the code is rewritten tomorrow, acceptance rate still calls it a success. For an adoption review, I would connect three timestamps: suggestion : accepted_at : 2026-07-19T09:00:00Z repository : api task_type : test change : retained_lines_24h : 31 rewritten_lines_24h : 9 reverted_at : null review : human_minutes : 12 incident_link : null Then report a funnel rather than one flattering percentage: shown → accepted → merged → retained_24h → retained_14d A useful unit is cost per retained task : (tool cost + review labor + rework labor) / retained tasks “Retained” needs a written contract. For example: the change remains merged after 14 days, passes required checks, and has not caused a linked rollback. Line survival alone is weak because formatting and refactoring can change lines without rejecting the solution. Segment the result by task type and repository. Boilerplate tests and unfamiliar security changes should not be blended into one portfolio average. Also publish counter-metrics: review time, escaped defects, rollback rate, and developer-reported interruption. GitHub documents available fields and limitations in its Copilot metrics API . Those product metrics can be inputs, but the retained-task join belongs to the adopting organization and should be versioned like any other analytics contract. My pilot gate would be simple: expand only if retained-task cost beats the existing workflow without worsening rollback rate. Otherwise, change the workflow before buying more seats. Record the baseline before enabling the tool, and keep one comparable task cohort outside the rollout; without that counterfactual, a rising retention rate may only reflect easier work entering the sample. What retention window would make an accepted change meaningful for your team?

What Changed DocuSeal has emerged as an open-source platform for digital document signing and processing. This project offers a self-hostable alternative to commercial services, allowing organizations to manage document workflows, eSignatures, and form filling within their own infrastructure. The platform is designed to be accessible, mobile-optimized, and integrates with existing systems through APIs and webhooks. Technical Details DocuSeal provides a comprehensive set of features for digital document management. Key functionalities include a WYSIWYG PDF form fields builder that supports 12 field types, such as Signature, Date, File, and Checkbox. It accommodates multiple submitters per document and automates email notifications via SMTP. For file storage, DocuSeal offers flexibility, supporting local disk storage as well as cloud providers like AWS S3, Google Storage, and Azure Cloud. The platform implements automatic PDF eSignature generation and includes a mechanism for PDF signature verification, addressing security and compliance requirements. User management is integrated, and the UI is mobile-optimized, supporting 7 UI languages with signing capabilities in 14 languages. Integration with other systems is facilitated through a robust API and webhooks. Deployment options are varied, catering to different infrastructure preferences. DocuSeal can be deployed on cloud platforms such as Heroku, Railway, DigitalOcean, and Render. For containerized environments, Docker images are available, allowing for deployment via docker run commands. By default, the Docker container utilizes an SQLite database, but it can be configured to use PostgreSQL or MySQL by setting the DATABASE_URL environment variable. Docker Compose configurations are also provided, enabling deployment with custom domains and automatic SSL certificate issuance via Caddy. Pro features, available through commercial offerings, extend the platform's capabilities to meet business needs. These include compa

OpenAI's July 14 guidance for managing AI investments recommends five moves: improve visibility into usage and spend, evaluate efficiency by outcome ROI, govern advanced workflows before scaling, fund workflows that compound, and match capacity to proven demand. Primary source: OpenAI, “How to manage AI investments in the agentic era” . The hard part is the denominator. “This agent used $800” says little. “This workflow cost $14 per accepted reconciliation, including review and rework” can support a decision. Here is a one-page ledger I would require for an agent pilot. Define one accepted outcome Do not start with tokens, seats, or tasks launched. Define the business state that counts after review. workflow : vendor-invoice-reconciliation accepted_outcome : " invoice matched, exceptions reviewed, result posted" owner : finance-ops pilot_window_days : 21 minimum_sample : 100 invoices quality_gate : false_postings : 0 exception_recall : " >= 0.98" reviewer_minutes_p50 : " <= 3" A generated draft is not an outcome if a person must rebuild it. An agent run is not successful if its result never enters the system of record. Capture the complete cost AI cost + orchestration and observability + human review + rework + incident handling + allocated implementation cost = total workflow cost Use a table with declared variables: Variable Meaning Example only C_model model and tool-call spend $600 C_platform workflow infrastructure $200 H_review reviewer hours 35 R_hour loaded reviewer rate $45 C_build pilot build cost allocated to window $2,000 N_accept accepted outcomes 850 total = C_model + C_platform + H_review * R_hour + C_build cost_per_accepted_outcome = total / N_accept With the illustrative numbers, total cost is $4,375 , or about $5.15 per accepted outcome. These are not benchmark claims; replace every value with measured data. Compare against the real baseline The baseline must use the same unit and quality gate: Metric Manual baseline Agent pilot attempted invoices

Last week an AI-generated GPU kernel ran 18.71× faster than an optimized PyTorch baseline. The model—Fable 5—didn't just edge past the human implementation. It lapped it. Claude Opus 4.8 reached 14.4×. GLM-5.2 hit 11.14×. GPT-5.5 managed 4.34×. Fable's kernel was in a different tier entirely. The exciting read: AI is starting to improve the low-level machinery that makes AI itself cheaper and faster. Specialized performance work that once required rare expertise just got dramatically easier to explore. The uncomfortable read: what happens when the best implementation is also the one nobody on your team would have written—or can fully explain? That question is about to land on every engineering team that ships AI-generated code. The Benchmark Problem A benchmark shows the kernel ran fast under tested conditions. It doesn't show: How it behaves across different GPU hardware How it handles numerical edge cases What happens under months of production changes Whether it degrades gracefully when inputs shift The person who wrote it can't answer these questions either. The AI generated this code through a process that doesn't leave a reviewable chain of reasoning. There's no commit message that says "I chose this approach because X." So the reviewer's job just got harder—not easier. The Real Shift I've been watching this pattern across engineering teams this year. The argument is moving from "can AI generate working code?" to "can our org absorb generated code without breaking quality, morale, or judgment?" The GPU kernel story makes the tension concrete: One side says the code ran, it was measured, it won. Stop moving the goalposts. The other side says somebody still has to know where it can fail and take responsibility when it does. Both are right. AI can make implementation cheaper while making proof more expensive. Senior engineers may write less code but spend more time designing adversarial tests, checking assumptions, planning rollbacks, and deciding whether an impr

Co-founded by serial entrepreneur Shai Morag, Israeli identity management startup Oak is emerging out of stealth with $60 million in seed funding.

Design + Product Thinking: NYC’s Path to Reliable AI AI delivers value when it’s useful, trusted, and operational. For city services that affect millions, those qualities don’t happen by accident — they come from applying design thinking (who the service is for, how it’s used) together with product thinking (what outcome we’re trying to achieve and how we operate over time). This article explains why hiring designers and product managers matters for NYC’s digital and AI initiatives, summarizes the city’s PIT Crew program, and outlines how Flamelit applies outcome-focused delivery in the public sector. Why design and product roles matter Designers and product managers have distinct but complementary responsibilities that reduce common AI delivery failures: Designers (Design Thinking): center human needs, prototype user flows, and validate that interfaces and decision workflows are understandable and accessible. They surface usability and trust issues early, preventing technically accurate models from becoming unusable in practice. Product managers (Product Thinking): define the measurable outcomes, prioritize use cases, align stakeholders, and manage the lifecycle from discovery to ongoing operations. They ensure work is evaluated against mission impact, not just technical metrics. Together they prevent common failures: building technically impressive models that nobody trusts, deploying brittle systems without human review, or shipping features with unclear ownership that decay in production. PIT Crew and NYC hiring context NYC’s PIT Crew program is a city initiative designed to attract and staff product, engineering, and design talent for public service projects. It’s a practical recognition that public-sector digital transformation needs people skilled in user research, product management, and delivery. Read more about the PIT Crew and how it works here: https://www.nyc.gov/content/pitcrew/pages/ (open in a new tab). Hiring programs like PIT Crew help create the c

Someone would ask a question in a public Slack channel. Every so often a couple of people would start to answer. Then the manager would step in, say what was going to happen, and the thread would go quiet. On its own, it looks like nothing. A decisive manager keeping things moving. But it was a team going quietly into debt, and the dead Slack thread was one of the interest payments. You already know tech debt. You cut a corner in the code to ship faster, and you pay interest on it later in bugs, slow changes, and the one file nobody wants to touch. Culture debt works the same way, except the corners you cut aren't in the code. They're in the norms, the expectations, and the relationships that decide how people actually work together. But tech debt is visible. You can see it, point at the file, write a ticket, argue about whether it's worth paying down. Culture debt is more dangerous because it gives you none of that. You don't watch it accruing. You see the symptoms, and by the time they show up, the debt has already compounded. Let me tell you how a team I joined got there. The reward was volume. The only thing that reliably got praised was pushing a lot of code. The manager was open about it...their whole framing of the job was being able to out ship anyone on the team. Everyone else stayed quiet. Nobody ever stood up and argued against quality. If you'd asked, the manager would have agreed that testing mattered and that quality mattered. Those things just never got prioritized. So over and over, what actually got rewarded (volume) quietly beat what everyone said they wanted. This didn't happen out loud. The reward silently won every time. You can guess what that bought. Planning went first, so features shipped in half finished states and got abandoned there. Testing basically didn't exist. We had a QA person, but things slipped through constantly. Bugs were everywhere. Plenty of features barely worked, and some just didn't. The human side hollowed out at the same

Most people assume better AI performance means a bigger bill. That assumption is quietly being proven wrong. The "Don't Touch It" Trap in AI Products There's a psychological pattern that shows up in almost every team running a live AI-powered product: once something works, nobody wants to mess with it. And honestly, that instinct makes sense. You've tuned your prompts, worked out the edge cases, trained your users, and finally gotten the thing stable. The idea of swapping out the underlying model - the engine of the whole operation - feels like pulling a thread that might unravel everything. So teams stay put. They watch new model releases come out, read the benchmark comparisons, and quietly decide it's not worth the risk. The phrase you hear most often is "if it ain't broke, don't fix it." The problem is that this logic made sense when model upgrades were expensive and disruptive. That's no longer the default reality. What's actually happening now is that AI providers are competing hard on price-per-token while simultaneously improving quality. That combination - better output, lower cost - breaks the old mental model most product people are still operating with. What a Model Migration Actually Involves Let's be clear: switching AI models isn't a one-click operation. But it's also not the months-long project many teams imagine it to be. At its core, a model migration for an AI agent involves three things: re-evaluating your prompts (because different models respond differently to the same instructions), running parallel tests to compare output quality on your real use cases, and updating any API parameters that differ between versions. That's the actual work. For most small-to-medium deployments, that's days of effort, not weeks. The bigger shift is in how you think about model versions. Rather than treating the model as permanent infrastructure, it helps to think of it more like a dependency in your software stack - something you update deliberately, test careful

Most organisations approach a Dynamics 365 Customer Engagement implementation with one question at the top of their agenda: How long will this take? It is a reasonable question, and one that deserves a precise, well-considered answer rather than a vague estimate designed to win the deal. The reality is that Dynamics 365 CE implementation timelines vary significantly, shaped by factors that are unique to each organisation: business complexity, data readiness, customisation depth, integration requirements, and internal stakeholder availability. This guide provides a structured, phase-by-phase breakdown of what a Dynamics 365 CE implementation actually involves, realistic timeline benchmarks by business size and industry, and the critical factors that either accelerate or delay your go-live date. Why there is no one-size-fits-all timeline for Dynamics 365 CE implementation Why There Is No Single Answer to the Timeline Question Dynamics 365 Customer Engagement is not a standalone application. It is a modular platform encompassing Sales, Customer Service, Field Service, and Marketing, each carrying its own configuration requirements, data dependencies, and user adoption considerations. A professional services firm deploying D365 Sales for a 25-person team operates in an entirely different context than a multi-national enterprise rolling out Customer Service and Field Service across three regions. Treating these as comparable projects, with comparable timelines, is where expectations first go wrong. As a reference framework, Dynamics 365 CE implementations broadly fall into three tiers: Implementation Scope Basic deployment, minimal customization :- 6 – 12 weeks Mid-market with integrations and moderate configuration :- 3 – 6 months Enterprise, multi-module or multi-region rollout :- 6 – 16 months These are informed benchmarks, not guarantees. What determines where your project lands within or beyond these ranges is examined in detail below. Core phases of a Microsoft Dyn

TL;DR Retailers process thousands of inventory transactions every second across physical stores, eCommerce platforms, warehouses, suppliers, and fulfillment centers. Yet many inventory systems still rely on scheduled synchronization, causing stock levels to become outdated within minutes. The result is overselling, delayed replenishment, inaccurate inventory visibility, and avoidable stockouts. Apache Kafka enables real-time inventory management by treating every inventory movement as an event that is streamed the moment it occurs. Sales, returns, warehouse transfers, supplier deliveries, and IoT sensor updates are continuously processed to maintain a consistent inventory view across all retail systems. This event-driven approach helps retailers improve inventory accuracy, automate replenishment, detect stockouts before they occur, and respond to changing demand in near real time. In this guide, you'll learn how Apache Kafka powers real-time inventory management, explore a production-ready reference architecture, understand how inventory events are processed across retail systems, and discover implementation best practices for building scalable, resilient inventory streaming applications. Introduction Retail inventory management has evolved far beyond tracking products on warehouse shelves. Today's retailers operate across physical stores, eCommerce platforms, online marketplaces, distribution centers, and supplier networks, where inventory levels change continuously throughout the day. Every sale, return, warehouse transfer, supplier delivery, and inventory adjustment impacts product availability, making accurate inventory visibility essential for delivering a seamless customer experience. However, many retailers still rely on scheduled synchronization between Point-of-Sale (POS) systems, Warehouse Management Systems (WMS), Enterprise Resource Planning (ERP) platforms, and online storefronts. While these systems perform different functions, they all depend on accur

WordPress 7.0, released on May 20, 2026, includes new AI infrastructure, a redesigned admin interface, and updated design tools. Key features comprise an AI Client, Abilities API, and Command Palette, alongside increased PHP requirements. Community feedback is mixed, particularly regarding AI integration. Developers are advised to consult the official documentation for upgrade guidance. By Daniel Curtis

The Smartest AI Workflow I Have Ever Seen Ran on Three Pages of Prompt Project managers are quietly building their own AI chief of staff. The duct tape is the interesting part. A few weeks ago I was talking with a project manager who runs large industrial projects. Real ones, with safety officers and subcontractors and go-live dates that cost serious money when they slip. Somewhere in the conversation he mentioned, almost apologetically, a side project of his. Every week, he feeds an AI model his project charter, the project plan, the risk register, the action tracker, and the last six weeks of status reports. Then he adds the current week's meeting notes and any relevant emails. On top of all that sits a prompt he has iterated on for months. It covers three A4 pages in font size 10. Out the other end comes a list of specific open topics he needs to chase down before writing his end-of-week status report. He has a second prompt that helps him prepare sharp questions for the weekly team meeting. A third one, about 200 lines, assembles everything and drafts the status report itself. He even runs scenario checks: the safety officer found discrepancies during vehicle inspections, the subcontractor says compliance takes two extra weeks, does this move the critical path and the go-live date? He called it manual and clunky. I think it is one of the most sophisticated AI workflows I have ever seen a working professional build, in any field. And I have been building software for a long time. But he was right about the clunky part. And the reason it is clunky tells you almost everything about where AI in project work is actually stuck. The analysis was never the hard part Here is the thing he said that stuck with me, close to verbatim: The AI is good at analysing lots of text sources. The challenge is to obtain all the information, and the effort to write it down comprehensively. Read that again. The intelligence is not the bottleneck. The bottleneck is assembly. Every single

GitHub had over 14,000 repositories. Fewer than half had clear ownership. Here's how we gave every active repository a validated owner in under 45 days, archived the rest, and made ownership the foundation for everything that followed. The post How GitHub gave every repository a durable owner appeared first on The GitHub Blog .

Blue Origin is raising $10 billion at a $130 billion pre-money valuation from Coatue Asset Management, Bezos himself, and other big-name investors, The New York Times reported.

Redux setup is a ceremony. You create a store, compose your reducers into a root tree, wrap your app in a Provider, register middleware, and configure enhancers — all before you write a single line of feature logic. SDuX Vault™ replaces that entire ceremony with two function calls and zero root configuration. Redux Store Ceremony A typical Redux application requires several files and configuration steps before state management is operational. Here is what a minimal Redux setup looks like for a single feature: // store.ts import { createStore , combineReducers , applyMiddleware } from ' redux ' ; import thunk from ' redux-thunk ' ; import { userReducer } from ' ./reducers/userReducer ' ; const rootReducer = combineReducers ({ users : userReducer , }); export const store = createStore ( rootReducer , applyMiddleware ( thunk ) ); // App.tsx — Provider wrapper required import { Provider } from ' react-redux ' ; import { store } from ' ./store ' ; function App () { return ( < Provider store = { store } > < UserList /> < /Provider > ); } That is 20+ lines of configuration across multiple files — and it only covers one feature. Add a second feature and you are back in the combineReducers file, composing another slice into the tree. Add middleware and you are threading enhancers through applyMiddleware . Add DevTools and you are composing composeWithDevTools on top. Every new feature touches the root configuration. Redux Requirement What It Does createStore() Creates the single global store instance combineReducers() Composes feature reducers into a root tree applyMiddleware() Registers middleware (thunk, saga, etc.) Provider Makes the store available to all components via context composeWithDevTools() Enables Redux DevTools integration ⚠️ Warning: Every entry in that table is root-level configuration. Adding a new feature means editing the root reducer composition, possibly the middleware stack, and potentially the Provider hierarchy. Root configuration is a shared depende

Amazon Web Services (AWS) has announced a major expansion of its AWS DevOps Agent, introducing new release management capabilities designed to assess code changes and autonomously test software before it reaches production. By Craig Risi

개발 역량이 없어도 외주 개발사의 진행 상황을 명확하게 파악하고 피드백을 줄 수 있다. 필요한 건 기술 지식이 아니라, 올바른 협업 구조다. 이 글은 비개발자 제품 관리자가 바로 적용할 수 있는 투명한 피드백 루프와 점검 방식을 소개한다. 외주 개발에서 비개발자가 소외되는 이유는 무엇인가? 외주 개발사와 일을 시작하면 처음 며칠은 소통이 활발하다. 요구사항 정리, 계약, 착수 미팅까지는 순탄하다. 문제는 그 이후다. 개발이 시작되면 대화의 언어가 바뀐다. "API 연결 중", "백엔드 스키마 설계 단계", "프론트 컴포넌트 분리 작업"처럼 전공자가 아니면 체감하기 어려운 표현들이 보고서를 채운다. 이 상태에서 비개발자가 할 수 있는 질문은 사실상 하나뿐이다. "잘 되고 있나요?" 그리고 돌아오는 답도 하나다. "네, 잘 되고 있습니다." 이 구조는 어느 개발사가 나쁜 의도를 가져서 생기는 문제가 아니다. 개발자는 기술 언어로 사고하고, 비개발자는 결과와 흐름으로 사고한다. 이 두 언어 사이에 다리가 없을 때 소외가 생긴다. 그리고 이 소외는 감정의 문제가 아니라 실질적인 리스크다. 방향이 틀어진 채 몇 주가 흐르면, 다시 맞추는 비용은 처음보다 훨씬 커진다. 비개발자가 개발 과정을 직접 점검할 수 있는 구조가 필요한 이유가 여기 있다. 비개발자가 진행 상황을 파악할 수 있는 협업 구조란? 투명한 협업 구조는 "보고를 더 자주 받는 것"이 아니다. 받는 정보의 언어와 형식을 바꾸는 것이다. 포텐랩은 매주 진행 상황을 공유하는 주간 피드백 루프를 팀 표준으로 운영한다. 이 루프의 핵심은 세 가지다. 무엇이 완료됐는가 : 이번 주에 실제로 만들어진 것, 확인 가능한 것. 다음 주에 무엇을 만드는가 : 다음 단계에서 기대할 수 있는 결과물. 막힌 것이 있는가 : 결정이 필요하거나 확인이 필요한 사항. 이 세 가지가 매주 비개발자도 읽을 수 있는 언어로 정리된다면, 소통 구조는 이미 절반 이상 해결된 것이다. 기술 용어 없이 "로그인 화면 완성, 다음 주엔 상품 목록 화면 작업"이라고 쓸 수 있다면, 비개발자는 지금 어디쯤 왔는지 감을 잡을 수 있다. 주간 피드백 루프를 실제로 설계하는 방법 주간 루프가 형식적인 보고에 그치지 않으려면 구조가 있어야 한다. 아래는 포텐랩이 프로젝트마다 적용하는 주간 피드백 사이클의 구성이다. 1단계 — 주간 업데이트 문서 공유 매주 정해진 요일에 개발팀이 업데이트 문서를 공유한다. 이 문서에는 완료된 기능, 다음 주 작업 항목, 그리고 결정이 필요한 사항이 포함된다. 형식은 슬랙 메시지든, 노션 페이지든 팀이 합의한 채널이면 된다. 중요한 건 형식보다 주기와 언어다. 매주 같은 날, 비개발자가 읽을 수 있는 언어로. 2단계 — 화면으로 확인 가능한 결과물 공유 텍스트 보고만으로는 실제로 무엇이 만들어졌는지 체감하기 어렵다. 그래서 주간 업데이트에는 화면 캡처, 동영상 클립, 또는 테스트용 링크가 함께 제공된다. "로그인 기능 완료"라는 문장보다 실제 작동하는 화면을 보는 것이 훨씬 구체적인 판단 근거가 된다. 3단계 — 비개발자가 직접 테스트하는 시간 개발팀이 보여주는 것만 보는 게 아니라, 비개발자가 직접 써보는 단계가 필요하다. 이 과정에서 "버튼이 너무 작다", "이 순서가 직관적이지 않다" 같은 피드백이 나온다. 기술 지식이 없어도 할 수 있는 피드백이고, 이런 피드백이 제품의 방향을 바로잡는다. 4단계 — 다음 주 작업 범위 합의 이번 주 결과를 확인한 뒤, 다음 주에 무엇을 만들지 함께 정한다. 이 단계에서 비개발자는 우선순위를 조정할 수 있다. "이 기능보다 저 기능이 먼저 필요하다"는 판단을 매주 할 수 있는 구조다. 우선순위는 비개발자가 가장 잘 아는 영역이다. 비개발자가 개발 진행 상황을 점검하는 실질적인 기준은? 개발 진행 상황을 평가할 때 기술적 판단을 할 필요는 없다. 다음 세 가지 기준으로 충분히 점검할 수 있다. 점검 항목 확인 방법 좋은 신호 주의가 필요한 신호 완료 결과물 화면 또는 테스트 링크로 직접 확인 매주 눈에 보이는 결과물이 있음 텍스트 보고만 있고

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

We started using Jira to manage our internal development workflow. At first it worked fine, but once we outgrew the free tier, the cost became hard to justify. At $15 per user per month, we were suddenly looking at a bill that did not match how we actually used the product. What we Built We created WannaTrack, a lightweight project management tool designed for small dev teams that do not need enterprise complexity. The goal was not to recreate Jira. It was to remove everything we did not use. Key ideas : minimal agile board with no clutter or heavy configuration simple issue tracking flow fast interface for daily development work minimal setup and no onboarding overhead Migration from Jira One of the biggest concerns was switching tools without breaking our workflow. So we built a Jira import tool that lets you migrate existing tickets into WannaTrack without manual effort. This allowed us to switch internally without downtime. Where it is now We now use WannaTrack daily for our own development workflow and are opening it up to other teams who feel the same pain with traditional tools. If you are a small dev team, indie hacker, or startup looking for a simpler issue tracker without overhead, you can check it out here: https://wannatrack.com

A year ago today, I started at Approov. A hundred days in, I wrote about the transition: leaving management, the refreshing day-to-day feedback loop, the strange experience of relearning a craft I thought I'd lost. I stand by most of it. But a hundred days is enough to notice a change; it takes a year to understand it. So here is what a year taught me that a hundred days couldn't. The rust that mattered At a hundred days I called myself rusty. I was. I reached for patterns that no longer fit and looked up syntax I once knew by heart. I expected that to be the hard part. It wasn't. The rust came off faster than I feared, and somewhere along the way I realised I'd been worried about the wrong thing entirely. The agentic era arrived in earnest this year, and it quietly rewrote the job description. The premium skill is no longer how fast you can produce code from memory. It's whether you can write a precise specification and make a strong architectural decision, then judge honestly whether what comes back is any good. Those are not new skills for me. They are the exact skills that years of reviewing architecture and mentoring engineers had been sharpening the whole time. The craft I sat down to relearn was not the craft that turned out to matter. I spent years assuming management had pulled me away from engineering. It hadn't. It had been quietly preparing me for the version of engineering that was coming. Charity Majors has a name for the shape of this: the engineer/manager pendulum. The idea that a healthy career swings between the two, rather than treating management as a one-way door you walk through once and never come back. I didn't choose when mine swung back. But it swung the right way, and the years spent on the other side weren't lost. They were compounding. A secure transaction is a secure transaction The work itself has been a homecoming of a different kind. I spent years in payments. Now I work in mobile and API security. On paper those are different worlds