标签：#war

By Sergio Colque Ponce — Software Engineering, Universidad Privada de Tacna. Full source code: github.com/srg-cp/spec-driven-development If you have used an AI coding agent — Copilot, Claude Code, Gemini CLI — you have probably lived this moment: you describe a feature, the agent produces code that compiles and looks right, and then it quietly does the wrong thing. The agent is not weak; the input was ambiguous. We have been treating coding agents like search engines when they behave more like very literal pair programmers. Spec-Driven Development (SDD) is the answer to that problem: instead of jumping straight to code, you write down what you want and why , refine it, and only then let the implementation follow. The specification — not the code — becomes the center of the project. What Spec-Driven Development actually is The idea is old (anyone who has written a Product Requirements Document will recognize it), but it has become practical again thanks to tools like GitHub's open-source Spec Kit . Spec Kit organizes the work into a small set of Markdown artifacts, each feeding the next: Constitution — the non-negotiable principles of the project (security rules, coding standards, architectural constraints). Spec — what you are building and why , with no implementation detail. Plan — the technical blueprint derived from the spec (stack, structure, decisions). Tasks — the plan broken into small, ordered, verifiable steps. Implement — the agent (or you) builds the tasks, with the previous artifacts as structured context. The workflow is usually summarized as Spec → Plan → Tasks → Implement , and the same process is meant to work regardless of language, framework, or which of the 30+ supported agents you use. The real shift is not "more documents." It is this: when requirements change, you update the spec, regenerate the plan, and let the implementation follow — instead of patching code and hoping the intent survives. The spec is a living artifact, not a dusty Word file

A common way to design an application is to begin with its nouns: User Product Order Payment Then each noun receives the standard architectural starter pack: UserController UserService UserRepository The controller receives users, the service services them, and the repository stores them somewhere responsible. This is noun-oriented architecture : treating every important thing in the domain as if it were automatically a useful software boundary. It works for simple CRUD systems. Unfortunately, most applications eventually do something. The noun becomes a drawer Consider a typical UserService : register() findByEmail() resetPassword() changeAddress() disableAccount() mergeAccounts() assignRole() calculateDiscount() These operations all involve a user. That is approximately where their similarity ends. They have different rules, dependencies, side effects, security concerns, owners, and reasons to change. They live together because User was the nearest available noun when the folders were created. As more behaviour accumulates, UserService becomes the official location for anything vaguely user-shaped. Other components depend on it. It gradually depends on authentication, email, permissions, billing, auditing, and several services added during incidents nobody wishes to revisit. The noun becomes both a dependency of everything and a consumer of everything. The folder remains impressively tidy. Name the capability, not the material A better starting question is not: What things exist in this system? It is: What must this system be capable of doing? That leads to components such as: UserRegistrar PasswordResetter AccountMerger OrderPlacer PaymentRefunder SubscriptionCanceller These are agentive names . They name the component responsible for performing a capability. Compare: UserService with: PasswordResetter UserService tells us which noun is nearby. PasswordResetter tells us what the component is for. That difference produces better architectural questions: What rules

The build-vs-buy question gets answered wrong in both directions. Scrappy teams build things they should have bought, wasting six months reinventing Stripe. Enterprise teams buy things they should have built, ending up with a duct-taped stack of ten SaaS products that cost more than a full-stack engineer. The real answer depends on five questions most decision frameworks don't ask. This guide is a practical walkthrough for anyone trying to figure out the right call for their own business. The Myth That Distorts Every Build-vs-Buy Conversation "Buying is cheaper." This is the default assumption, and it's wrong often enough to be dangerous. Buying looks cheaper because the cost is monthly instead of upfront -- a psychological trick, not an economic one. Run the numbers on any SaaS tool over 5 years and you'll usually find the cost lands within 2x of building custom. Sometimes below. The real cost difference is not price; it's time, flexibility, and ownership. When you buy: You spend less today, more in year 3 You get speed now, rigidity later You trade money for control You own none of the code When you build: You spend more today, less per year You trade speed now for flexibility later You trade money for control You own the code and can change anything Both are rational trades. The question is which one matches the stage and strategy of your business. When Buying Wins Start with the easy case. Buy off-the-shelf when: 1. The problem is generic and solved. Email hosting, payment processing, accounting, HR payroll, customer support tickets, video conferencing, file storage. These are solved problems. Building your own is nearly always the wrong call. 2. The space has mature competitive options. If there are 5 reputable companies competing on price and features, you benefit from that competition. Building custom takes you out of it. 3. Your process is standard. If you do exactly what every other company in your vertical does, a tool built for every company in your verti

“People just really want to take back control of their time, their lives, their attention... They’re down for whatever helps them do that.”

There is a quiet tax many engineering teams pay after their automated test suite starts to matter. The tests live in code. They run in CI. They already know the branch, commit, environment, failure message, stack trace, screenshot, trace file, retry status, and build URL. Then someone asks: Can we put these tests in Jira too? That request usually comes from a good place. Jira is where work is planned. Product, QA, engineering, and release stakeholders already use it. If quality signal is invisible there, people end up asking for screenshots from CI, links to failed builds, or spreadsheet summaries before every release. The mistake is assuming the answer is to recreate every automated test as a manual Jira test case. For many teams, that creates a second source of truth that starts decaying immediately. Automated tests are not manual test cases Manual test cases and automated tests have different jobs. A manual test case is a human-readable procedure. It often describes a workflow, expected result, and maybe some preconditions. It is useful when a person needs to execute or review a scenario. An automated test is executable behavior. It is versioned with the code, refactored with the product, reviewed in pull requests, and run repeatedly by machines. When teams try to manage automated tests by copying them into a test-case inventory, they usually create a translation problem: The test name changes in code, but the Jira case does not. The test is deleted or split, but the manual record still exists. The CI failure has rich evidence, but the test case only says "failed." The test belongs to a branch or commit, but the copied case does not. The release team sees a static inventory instead of the latest run signal. The test case becomes a label for a thing that actually lives somewhere else. The better question Instead of asking, "How do we turn all automated tests into Jira test cases?", ask: What does Jira need to know from each automated run? That changes the shape of

Partner tells Ars that HPE should be giving out more free VM Essentials licenses.

There is a comparison that the artificial intelligence industry had kept out of the public conversation until now. Satya Nadella brought it up this Sunday in a post on X that garnered over a thousand responses in just a few hours. The metaphor he used is "industrial offshoring" . Just as the first wave of globalization hollowed out industrial economies, wiping out factory jobs and decades of competitive advantage with consequences we still feel today, artificial intelligence threatens to do the same to corporate knowledge. The Silent Drain of Expertise The mechanism Nadella describes is concrete. If an organization hands over its workflows, its domain knowledge, and the accumulated judgment of its teams to external AI models, those models absorb it. What was once a unique advantage, now could become a generic capability available to everyone. There are no layoffs or plant closures. The hollowing out happens silently, in every usage cycle, in every operation the model records and leverages. Where there was once exclusive know-how, there is now a standard resource. "You can outsource a task, or even a job. But you can never outsource the learning." Microsoft CEO Warns That AI Winners Could Hollow 'Entire Industries' - Business Insider AI models are hoovering up corporate knowledge, and that's leaving one big loser, says Satya Nadella. businessinsider.com The Invisible Asset / The Identity This warning is not directed at employees but at executives. The risk Nadella identifies is not the loss of an individual position, but the erosion of the organisation's collective intellectual property, its processes, and the judgment a team spends years building. To name this, he introduces a term that was not in the business management vocabulary until now: "Token Capital" . This represents the layer of agentic capability that a firm builds and owns when it connects its real workflows with the AI models it uses. It is not software or a database. It is a system that learns with eve

Trump admin green-lighting $111B deal "reeks of corruption," Sen. Warren says.

Qualcomm's CEO said today that the company is working on over 40 new AI hardware designs

For over a decade now, Snap has been working on this device. Now the glasses are finally here. So what stands out on first impression?

Plaud is trying to make a mark in a crowded market full of AI-powered meeting notetakers.

I'll just work from the car, I thought. But after a few minutes of staring at my screen on quick mountain switchbacks I could feel the first signs of cold, coagulated nausea bubbling up from that sweaty place in my gut. I looked to the horizon for relief, but nothing helped… until I remembered Apple's […]

We Built Korexbase: A Lead Generation Platform for Finding Business Leads by City and Niche Building software is exciting. Building software that solves a real problem is even better. Over the past few months, we've been working on Korexbase , a lead generation platform designed to help businesses discover targeted leads faster. The Problem Many agencies, sales teams, freelancers, and startups spend hours manually searching for potential customers. The process usually looks something like this: Search for businesses online Collect contact information Copy everything into spreadsheets Repeat the process every day It's slow, repetitive, and difficult to scale. We wanted to simplify that workflow. The Idea Korexbase allows users to search for business leads by: City Industry Business category Instead of manually collecting data, users can generate leads and manage them through a clean dashboard. The goal isn't to replace sales. The goal is to help businesses spend less time searching and more time closing deals. Building the Platform A major focus during development was creating a dashboard that feels simple and easy to navigate. Some areas we focused heavily on included: Responsive layouts User-friendly navigation Clear data presentation Fast loading interfaces Consistent design patterns Challenges Like most projects, we faced a number of challenges: Designing for Simplicity One of the biggest lessons was that adding more features doesn't automatically create a better product. We spent a lot of time simplifying interfaces and removing unnecessary complexity. Creating a Better Dashboard Experience Presenting lead generation data in a way that is useful without overwhelming users required multiple design iterations. We focused on: Better spacing Better visual hierarchy Cleaner cards and tables Improved responsiveness Product Positioning An interesting challenge was refining the product's positioning. As development progressed, we learned more about what users actually w

How many times have you seen a picture of a plane with red dots posted on the internet without context? There's a famous story about a statistician named Abraham Wald and a bunch of WWII bombers. The military looked at the planes coming back from combat, mapped where they were riddled with bullet holes, and decided to add armor there. Wald, being the kind of person who ruins meetings by being right, pointed out the obvious thing nobody wanted to hear: The planes they were looking at came back . The ones hit in the spots with no bullet holes, the engine, the cockpit, were at the bottom of the English Channel, not available for the survey. Reinforce the parts that aren't shot up. That's where the dead planes got hit. I think about this story a lot, mostly while reading those blog posts titled "X Habits That Made Me a 10x Engineer." The entire industry is a returning-plane survey Here is the uncomfortable thing about software engineering wisdom: almost all of it is collected from the planes that came back. Successful companies write blog posts. Successful founders do podcast tours. Successful engineers give conference talks with titles like "Scaling to 100 Million Users with Three People and a Dream." The companies that did the exact same things and died do not have a booth at the conference. They are not on the panel. They are in the channel, with the engines. And yet we keep doing the survey. We stare at the bullet holes on the survivors and go, "Ah, this is where we add armor." "Netflix uses microservices, so we should too" You have eleven users. Three of them are your co-founders, and one is your mom. Netflix runs a globe-spanning streaming empire on hundreds of microservices because they have hundreds of teams, billions in revenue, and problems you will be lucky to have in a decade. You have a Postgres database that is doing just fine, thank you, and a monolith that boots in four seconds. So naturally, you spend the next eight months splitting your perfectly funct

Agentic QA Pipelines: Why Your Test Scripts Are Already Obsolete You wrote the test. You maintained the test. The app changed. You rewrote the test. If that loop sounds familiar, you're not alone — and in 2026, you're also not competitive. Agentic QA pipelines are replacing script-based test automation not because AI is smarter than your QA engineers, but because describing goals is faster than maintaining instructions. Here's what's actually changing, why it matters, and how forward-thinking teams are shipping without the script debt. The Script Maintenance Tax Is Killing Velocity Traditional test automation follows a simple premise: write explicit instructions, run them, check results. It worked when applications changed slowly and test environments were stable. In 2026, neither is true. AI-generated code ships faster. Features change in days. UI components regenerate. And every change breaks a percentage of your carefully maintained test scripts — creating a maintenance tax that grows proportionally with your automation coverage. Quash's 2026 State of QA Automation Report found that teams spending more than 30% of QA bandwidth on script maintenance are shipping 2.4x slower than teams that have automated that maintenance layer away. The irony: the more test coverage you write, the more you're paying the tax. What Agentic QA Actually Means (Without the Buzzwords) An agentic QA system doesn't follow a script. It follows a goal. Instead of: Click the login button Enter " testuser@example.com " in the email field Enter "password123" in the password field Assert redirect to /dashboard An agentic QA agent receives: Goal: Verify that a registered user can successfully authenticate and access their dashboard. Context: Auth flow supports email/password and OAuth. Dashboard loads user-specific data. The agent then: Explores the auth flow autonomously Generates test scenarios, including edge cases it infers from the UI Executes tests, reads failures, and adapts to UI changes

There are already many posts about what agent skills are and how to create your own, so in this post I want to dive into the various skills I use to assist in development. The Skills Grill Me Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me". I start every larger task with this excellent skill created by Matt Pocock. I either start this with an already prepared PRD / detailed task description or use it for discovery purposes. The agent will then ask many questions to align language and functional requirements, so fewer hallucinations happen in follow up requests. You should be well equipped to answer the agent's question or the grill me session can go on for a long time. I had it ask me way over 50 questions when not answering detailed enough. As a little extra I added an extra request to the skill to prompt me if I want to create the PRD when the alignment phase is over, this leads us to the next skill. To PRD Turn the current conversation context into a PRD. Use when user wants to create a PRD from the current context. This will simply take the current conversation and creates a PRD out of it, we do this to summarize the conversation so we can easily start a new context window with all information present To Issue Break a plan, spec, or PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Use when user wants to convert a plan into issues, create implementation tickets, or break down work into issues. Another excellent skill by Matt Pocock. I modified the skill slightly to use the GitHub MCP to create issues based on a PRD or planning session. But I often found that letting an agent implement those tasks it resulted in a large amount of code and that is why I added the to tasks skill To Task Break down a single GitHub issue into a sequential list of small i

You scan one to pay at a sari-sari store, pull up a restaurant menu, or board a flight. The QR code has quietly become one of the most universal pieces of interface design on the planet. But it was never meant for any of that. The QR code was invented in 1994 to solve a very specific problem on a Japanese car factory floor, and the engineering decisions made under that constraint are exactly why it later conquered the world. A barcode problem on the assembly line In the early 1990s, Toyota's manufacturing arm had a data problem. Tracking thousands of distinct components through production meant scanning barcodes, and barcodes are stingy: a standard one-dimensional barcode holds roughly 20 characters. Workers were ending up with parts plastered in ten or more barcodes just to encode enough information, and each one had to be scanned separately. It was slow, and on an assembly line, slow is expensive. Masahiro Hara, an engineer at Denso Wave, a Toyota subsidiary, took on the challenge of designing something better. He wanted a code that could hold far more data, be read much faster, and tolerate the dirt, smudges, and odd angles of a real factory rather than a clean lab. Designing for speed and any angle The breakthrough was going two-dimensional. By encoding data in a grid of black and white squares rather than a single row of lines, Hara's team could pack in thousands of characters instead of a few dozen. The name they chose, QR for "Quick Response," was a direct promise about scanning speed. The most recognizable feature of a QR code, the three large squares in its corners, solves the hardest part of the problem: letting a scanner instantly find the code and work out its orientation no matter how the part is turned. Hara's team analyzed printed material to find a black-and-white sequence that almost never occurs naturally in text and images, and settled on a ratio of 1:1:3:1:1 for those corner markers. Because that pattern is so rare in everyday print, a scanner ca

You've heard of Bitcoin. You've maybe heard of the Lightning Network. But what exactly is LND, and why should developers care? Let's break it down — technically, but from the ground up. The Problem: Bitcoin is Superb but Slow Bitcoin's base layer — the blockchain itself — is intentionally slow. Every transaction must be broadcast to thousands of nodes, verified, and bundled into a block that gets mined roughly every 10 minutes . The network handles about 7 transactions per second (TPS). Compare that to Visa's ~24,000 TPS and you quickly see the problem. Bitcoin in its raw form isn't built for buying coffee, splitting a bill, or paying a freelancer in real time. But there's a solution — and it lives on top of Bitcoin. Enter the Lightning Network The Lightning Network is a Layer 2 (L2) payment protocol built on top of Bitcoin. Instead of recording every single payment on the blockchain, it lets two parties open a private payment channel, transact off-chain as many times as they want, and only settle the final balance on-chain when they're done. Think of it like running a tab at a bar: Opening the tab = one blockchain transaction Each round of drinks = instant off-chain payment Closing the tab = one final blockchain transaction The result? Near-instant payments, near-zero fees, and massive throughput — without sacrificing Bitcoin's security. What is LND ? LND stands for Lightning Network Daemon. It's the most widely used implementation of the Lightning Network protocol, built and maintained by Lightning Labs. Key facts for developers: Written in Go 🐹 Exposes a gRPC API (port 10009) and a REST API (port 8080) Controlled via a CLI called lncli Uses macaroons for authentication (think JWT, but for Lightning) Connects to a Bitcoin node (bitcoind or btcd) as its source of truth Other Lightning implementations exist — like Core Lightning (CLN) and Eclair — but LND has the largest developer ecosystem and is the best entry point. How LND Fits Into the Stack Here's the architec

As developers, we compare files constantly — reviewing pull requests, checking config changes, spotting bugs between versions. But not all diff tools are created equal. Some require installation, some upload your files to remote servers, and some just don't support the formats you need. Here's a rundown of the best free file diff tools available in 2026, so you can pick the right one for your workflow. 1. FileDiffs — Best for Privacy & Format Support If you work with sensitive files or just don't want your data sitting on someone else's server, FileDiffs is the tool you need. What makes it stand out: Supports 60+ file formats — PDF, Word, Excel, code files, JSON, XML, CSV and more Runs entirely in your browser — client-side processing means your files never leave your device 100% private — zero data transfer, zero uploads, zero risk No install, no signup, no hassle — just open and compare It's the go-to tool when you need to compare files quickly without worrying about privacy or compatibility. 2. Meld — Best Desktop Diff Tool Meld is a classic open-source visual diff and merge tool for Linux, Windows, and macOS. It's great for comparing files, directories, and version-controlled projects. Best for: Developers who prefer a desktop app and work heavily with Git. 3. Beyond Compare — Best for Power Users Beyond Compare is a feature-rich diff tool with support for files, folders, FTP, and cloud storage. It's not free (paid after trial) but worth mentioning for its depth of features. Best for: Teams that need advanced folder sync and merge capabilities. 4. Diffchecker — Quick Online Diffs Diffchecker is a simple web-based diff tool for text and code. It's quick and easy but uploads your content to their servers and has limited format support compared to FileDiffs. Best for: Quick one-off text comparisons where privacy isn't a concern. 5. KDiff3 — Best for Three-Way Merges KDiff3 is a free, open-source diff and merge tool that supports three-way comparison. It's a bit dat

Most of the code in Quorum was written by directing Claude Code, an AI coding agent. That is not the interesting claim, and on its own it is not even a good one. An agent left to run unsupervised produces fast, plausible, locally-correct code that drifts into an incoherent system. The interesting part is the discipline that turned agent speed into a coherent, correct, multi-region database application. That discipline was an append-only architecture decision log. The failure mode of agent-built software An agent has no memory across sessions. It will happily contradict a decision it "made" yesterday, re-open a question that was settled last week, or quietly drift from the design because the local change in front of it looks fine. Each individual output is reasonable. The aggregate, without governance, is a system where the data model fights the access layer and the third change undoes the first. This is the part people underestimate when they talk about AI coding velocity. Speed without a source of truth does not get you to a good system faster. It gets you to entropy faster. A fast writer with no memory and no sense of consequence is a liability at scale unless something outside the agent supplies the continuity. The decision log Quorum carries a file of numbered architecture decisions, DEC-001 onward, now past two dozen. Each entry has the same shape: the context that forced the decision, the decision itself, references to the prior decisions it refines or interacts with, and a status. Three rules make it work: Append-only. Entries are never edited. A later decision can supersede an earlier one, but it does so as a new numbered entry that references the old one. The history of why the system is shaped the way it is stays intact and readable, including the choices that were later reversed and why. Committed separately from code. The decision and the code that implements it are different commits. The log reads as a clean narrative of intent, independent of the diffs