Tagged articles
test-driven development
62 articles · Page 1 of 1
The author challenges AI coding hype with five practical engineering questions about complex data structures, quality evaluation without human verification, correctness of complex computations, impossible requirements, and test case reliability, arguing that AI cannot fully replace programmers and that the key is delineating human-AI boundaries.
AI codingAI limitationsPrompt engineering
0 likes · 7 min read

The mattpocock/skills repository provides 27 Markdown-based skill files that instill engineering discipline into AI coding assistants like Claude Code and Codex, enforcing practices such as requirement questioning, test-driven development, and dual-axis code review through slash commands and automatic behavioral rules without dictating implementation details.
AI coding assistantsClaude CodeEngineering Discipline
0 likes · 12 min read

Superpowers is an open-source skill library that injects mandatory TDD, sub-agent delegation, and two-phase code review into AI coding agents like Claude Code and Cursor, preventing 'works-on-my-machine' code by enforcing engineering discipline through workflow hooks rather than model upgrades.
AI coding agentsClaude CodeCursor
0 likes · 10 min read

The article reviews Matt Pocock's open-source 'skills' repository (238K stars, 18M+ installs), which codifies classic software engineering practices—requirement clarification via AI questioning, test-driven development, bug diagnosis protocols, architecture improvement, and end-to-end workflow automation—into lightweight, triggerable skill files for AI coding assistants like Claude Code, emphasizing human judgment over rigid frameworks.
AI coding assistantsClaude CodeMatt Pocock
0 likes · 12 min read

The article dissects the Superpowers plugin for Claude Code, revealing how its 14 Markdown-based skills enforce engineering discipline — from brainstorming's hard-gate design approval to systematic debugging's four-phase root-cause process, writing-plans' granular task breakdown, subagent-driven execution, and finishing-a-development-branch's clean closure — forming a complete workflow that eliminates AI shortcut-taking.
AI-assisted developmentClaude CodeEngineering Discipline
0 likes · 20 min read


FunTesterAug 17, 2026 · Artificial Intelligence
An exploratory evaluation shows that forcing AI coding agents to follow strict Test‑Driven Development does not improve design or mutation‑testing scores and can inflate token usage several‑fold, suggesting that result‑based feedback is a more effective control mechanism.
AI codingAgentic CodingPrompt engineering
0 likes · 15 min read

The article examines the popular GitHub repository mattpocock/skills, detailing how its four Claude Code skills—/grill-me, /tdd, /to-issues, and /diagnose—introduce deliberate friction into AI‑assisted programming, compares them with similar projects, and argues that the next wave of AI coding will prioritize disciplined, constraint‑driven workflows over raw speed.
AI codingClaudeGitHub
0 likes · 10 min read

The article dissects Matt Pocock’s /tdd and /diagnosing-bugs skills, showing how explicit feedback signals, red‑capable commands and a six‑phase linear debugging flow prevent agents from guessing root causes and improve the reliability of AI‑assisted bug triage.
AI agentsdebugging workflowfeedback loop
0 likes · 20 min read

The article outlines a systematic approach to selecting Superpowers skills across development stages, risk levels, task coupling, and problem types, provides concrete scenario examples and a decision table, and highlights common pitfalls to avoid over‑use or mis‑application of these skills.
R&D managementSuperpowersskill selection
0 likes · 11 min read

This article provides a detailed walkthrough of every official Superpowers skill—including identifiers, trigger rules, applicable scenarios, execution logic, and manual commands—and demonstrates how to combine these skills in multiple real‑world development workflows such as new feature delivery, urgent bug fixes, parallel task development, PR review remediation, core code refactoring, and multi‑demand parallel development.
AI workflow automationGit worktreesSuperpowers
0 likes · 22 min read

Superpowers adds a disciplined engineering framework to Claude Code by enforcing requirement clarification, test‑driven development, and isolated sub‑agent execution, turning AI‑generated code from flaky prototypes into traceable, maintainable software.
AI programmingClaude CodeGit Worktree
0 likes · 12 min read

This article dissects OpenSpec’s four‑step AI programming workflow, exposing why completing the process often still yields buggy code, and proposes five concrete upgrades—including spec reviews, atomic task checks, runtime verification, TDD practices, and archive gate‑keeping—to close the quality gap.
AI programmingOpenSpecautomation
0 likes · 16 min read

This guide walks developers through installing and using Matt Pocock Skills—a lightweight, composable set of AI‑agent commands that provide deep alignment, shared language, feedback loops, architecture reviews and token‑saving modes to turn "vibe coding" into repeatable, high‑quality delivery.
AI codingdocumentationsoftware engineering
0 likes · 19 min read

This article walks through a complete 7‑stage Superpowers workflow—brainstorming, isolated git worktrees, fine‑grained task planning, sub‑agent execution with two‑stage reviews, strict test‑driven development, global code review, and final branch finishing—using Python 3.11, FastAPI, SQLAlchemy and Pytest to implement robust SKU inventory deduction in an e‑commerce system.
AI programmingFastAPIGit worktrees
0 likes · 20 min read

Superpowers is an open‑source AI‑coding agent framework that enforces a seven‑step workflow with 14 composable skills and three strict iron laws—mandatory testing, root‑cause debugging, and fresh verification—to make AI‑generated code more reliable, maintainable, and compliant across new projects, feature additions, and bug fixes.
AI programmingSuperpowersagent-based development
0 likes · 17 min read

The article examines why AI agents need a unified workflow, introduces three popular tools—Spec‑Kit, OpenSpec and Superpowers—details their architectures, data‑flow and core features, shows practical installation and usage examples, and offers scenario‑based recommendations and limitations to help developers pick the right solution.
AI coding workflowOpenSpecSpec Kit
0 likes · 12 min read

The article compares two AI‑coding workflow frameworks—OpenSpec, which adds a structured, delta‑based specification layer, and Superpowers, which enforces behavior discipline through markdown‑driven skills—evaluating their mechanisms, strengths, weaknesses, and best‑fit scenarios for solo developers, large teams, and hybrid projects.
AI coding workflowDelta specsOpenSpec
0 likes · 21 min read

Superpowers prioritises evidence over intuition by enforcing three hard constraints—test‑driven development, systematic debugging, and verification‑before‑completion—to prevent shortcut thinking, ensure a solid evidence chain, and keep AI‑assisted engineering disciplined and reliable.
AI codingEvidence-Based Developmentcode quality
0 likes · 13 min read

Superpowers, a GitHub project with over 100 k stars, provides a composable skill framework that transforms AI coding assistants from impulsive code generators into disciplined engineers by enforcing requirement discussions, task decomposition, sub‑agent driven development, and strict TDD, while supporting multiple platforms and offering extensible built‑in skills.
AI codingClaudeSKILL framework
0 likes · 9 min read

The article critiques the chaotic output of AI coding assistants like Claude Code and Codex, then introduces the open‑source Superpowers framework—now with nearly 90 000 GitHub stars—that guides agents through a systematic, seven‑step engineering workflow including brainstorming, isolated environments, task decomposition, test‑driven development, code review, and final integration.
AI codingClaudeCursor
0 likes · 6 min read

The article analyzes the Superpowers open‑source project, which adds a structured engineering skill system to Claude Code, addressing context loss, workflow repetition, goal drift, and quality blind spots through a seven‑stage, TDD‑driven workflow that improves traceability, reproducibility, and efficiency.
AI coding assistantClaude CodeGit worktrees
0 likes · 7 min read

This guide introduces Superpowers, a three‑step workflow (brainstorm, write‑plan, execute‑plan) for using Claude Code or OpenCode to make AI‑generated code more reliable, maintainable, and aligned with developer intent, complete with commands, examples, and best‑practice tips.
AI coding workflowClaude CodeOpenCode
0 likes · 10 min read

In the AI era, product development is being reshaped by three revolutions—speed, organization, and engineering—where traditional month‑long cycles give way to day‑level delivery, solo ‘super‑individuals’ replace siloed teams, and AI‑driven code generation is constrained by DSLs, prompt engineering, and evolved test‑driven development.
AIPrompt engineeringproduct development
0 likes · 9 min read

This guide distills twelve core best‑practice secrets—derived from 720,000 paying users and a billion lines of daily code—on how to make AI agents obey prompts, plan before coding, manage context, use rules, custom commands, hooks, multi‑agent parallelism, and test‑driven development for reliable, high‑productivity outcomes.
AI AgentBest PracticesPrompt engineering
0 likes · 18 min read

This article walks through a real‑world Go project, showing why adding unit tests to core modules prevents regressions, how to mock tightly‑coupled dependencies, and provides complete example test code and best‑practice tips for reliable backend development.
BackendMocktest-driven development
0 likes · 13 min read

This article examines how early PHP developers often wrote tangled, procedural code that mixes business logic with presentation, and outlines concrete steps—adopting OOP, design patterns, domain‑driven design, test‑driven development, and modern tooling—to shift toward a cleaner, more maintainable backend development approach.
OOPPHPbackend development
0 likes · 7 min read

This article introduces a test‑driven AI programming loop that tackles the “last‑mile” problem of AI‑generated code by adding automated acceptance, self‑testing, bug fixing, and continuous iteration, demonstrated through a favorite‑count feature repair case and outlining future enhancements.
AI programmingContinuous Integrationcode generation
0 likes · 13 min read

This article explores Test‑Driven Development (TDD) as a quality‑focused methodology, detailing its practical benefits, planning strategies, documentation support, team collaboration gains, and the challenges faced in fast‑paced, high‑change environments, while offering balanced advice for integrating TDD with traditional testing approaches.
TDDcode qualitysoftware engineering
0 likes · 10 min read

Discover twelve practical techniques—from setting clear project rules and crafting precise prompts to modular development, test‑driven generation, context management, and model selection—that help developers maximize productivity and code quality when working with AI‑powered editors like Cursor, Windsurf, or CodeBuddy.
AICursorProductivity
0 likes · 15 min read

This article, based on Dave Farley's video, defines bad code by two fundamental criteria, explains how high‑quality code boosts development speed by 44% according to DORA research, explores deep aspects of readability, and offers concrete practices such as TDD, modular design, clear naming, and complexity control.
code qualitymaintainabilityreadability
0 likes · 4 min read

This article explains how AI‑generated code can be fast but unreliable, and demonstrates how applying Test‑Driven Development (TDD) with concrete Python examples catches errors like stack overflows, edge‑case failures, and security issues, ensuring robust, maintainable software.
AIPythoncode generation
0 likes · 13 min read

The article explains TDD’s core three laws, its rapid feedback loop, common implementation challenges with practical solutions, ways to enhance effectiveness through BDD, CI, and static analysis, and the long‑term benefits of reduced technical debt and improved code quality.
Continuous IntegrationTDDagile-practices
0 likes · 4 min read

This article outlines seven practical reasons why unit testing is crucial for developers, highlighting how automated tests provide fast feedback, improve code robustness, guide design, boost confidence, act as problem detectors, serve as reliable documentation, and accelerate learning of new APIs.
code qualitysoftware engineeringsoftware testing
0 likes · 5 min read

Test‑Driven Development (TDD) is a software development methodology that guides developers to write failing tests first, then implement minimal code to pass them, and finally refactor, offering benefits such as higher code quality, clearer requirements, safer refactoring, and reduced long‑term maintenance costs.
agile-practicescode qualityrefactoring
0 likes · 7 min read

This article explains the core concepts, rhythms, and practical applications of Test‑Driven Development (TDD) and Behavior‑Driven Development (BDD), illustrating how the red‑green‑refactor loop and business‑focused scenarios improve code quality, design, and collaboration between developers and stakeholders.
BDDBehavior Driven DevelopmentTDD
0 likes · 19 min read

The article traces David Farley's pioneering use of automation and continuous integration, his role in the Agile Manifesto, the impact of his books "Continuous Delivery" and "Modern Software Engineering", and his advocacy of Test‑Driven Development as a practical way to overcome bureaucratic software engineering pitfalls.
Continuous DeliveryDavid Farleytest-driven development
0 likes · 8 min read

This article explains the fundamentals of Test‑Driven Development (TDD), highlights common misconceptions, guides tool selection, and walks through a complete Java TDD case study—including a strange calculator example, multi‑iteration refactoring, and DDD‑based testing—showing how to improve code quality and maintainability.
DDDJavaMockito
0 likes · 26 min read

This article offers pragmatic, engineering‑focused advice on why unit testing matters, what makes a good test, when to write or skip tests, who should write them, and how to structure tests using the classic arrange‑act‑assert pattern.
code qualitysoftware testingtest-driven development
0 likes · 7 min read

Test‑Driven Development (TDD) is an incremental, test‑first methodology that emphasizes writing failing tests before code, integrates refactoring, supports both unit and acceptance testing, addresses myths, tools, and its extension with Agile Model‑Driven Development, offering a disciplined approach to improve design and quality.
AgileTDDsoftware testing
0 likes · 21 min read


DevOpsJan 4, 2023 · Fundamentals
The article explains how Test‑Driven Development is fundamentally a mindset that emphasizes predefined standards and expectations, explores related practices such as contract testing, acceptance criteria, and standard‑driven development, and discusses the challenges of defining, maintaining, and motivating adherence to these standards within agile teams.
AgileContract TestingTDD
0 likes · 6 min read

The article explains how Test‑Driven Development (TDD) boosts code quality, embeds domain knowledge, builds reusable automated test suites, and ultimately raises development efficiency, especially for middle‑platform services that must serve multiple business scenarios.
TDDsoftware qualitytest-driven development
0 likes · 5 min read

Test‑Driven Development (TDD) flips the traditional coding workflow by writing failing tests first, then code to pass them, enabling safer design changes, higher internal quality, and seamless integration with ATDD/BDD to ensure delivered software meets user requirements.
BDDTDDtest-driven development
0 likes · 8 min read

This article explains why testing—especially unit testing—is essential, compares the "egg‑roll" and "test pyramid" models, introduces test‑driven and test‑first development, discusses simple testing practices, and outlines refactoring principles and quality guidelines for developers.
refactoringsoftware qualitytest pyramid
0 likes · 11 min read

This guide presents a mentor‑driven onboarding framework that helps new R&D engineers quickly overcome language and project challenges by focusing on essential programming concepts, fast‑learning tags, experiment‑driven and test‑driven development, and clear project hand‑off procedures, ultimately boosting team delivery speed.
Programming LanguageR&D managementexperiment-driven development
0 likes · 10 min read

This article introduces Test‑Driven Development (TDD), walks through a complete FizzBuzz kata using Jest, explains the Red/Green/Refactor cycle, showcases common TDD patterns, and discusses challenges and best practices for writing clean, well‑tested code.
FizzBuzzJavaScriptTDD
0 likes · 17 min read

The article analyzes the key obstacles faced by software testing teams when working remotely—such as communication gaps, collaboration hurdles, technical failures, and documentation issues—and proposes practical solutions including video calls, automated regression testing, test‑driven development, and Selenium‑based tools.
automationdistributed teamsremote testing
0 likes · 8 min read


DevOpsOct 9, 2020 · Fundamentals
The article argues that many agile implementations are misapplied, creating pressure and defects for developers, and proposes that developers focus on proven software development practices such as extreme programming, continuous delivery, and test‑driven development rather than blindly following flawed agile frameworks.
AgileExtreme Programmingsoftware development
0 likes · 9 min read

The article explains why traditional GUI testing is fragile, outlines the benefits of shifting to API testing—including early verification, automation, and comprehensive coverage of positive, negative and edge cases—and offers practical guidance for integrating API tests into an agile CI workflow.
API TestingAgileREST
0 likes · 6 min read

This article explores the core principles of frontend testing, comparing Test-Driven Development and Behavior-Driven Development methodologies while providing a step-by-step tutorial on configuring the Jest framework and utilizing its essential matchers to write robust, maintainable unit tests for modern web applications.
Behavior Driven DevelopmentFrontend TestingJest
0 likes · 12 min read


DevOpsJul 7, 2020 · Fundamentals
Built‑in quality emphasizes integrating quality throughout the software development lifecycle, using agile principles, continuous integration, test‑driven development, code review, and shared code ownership to reduce technical debt, avoid rework, and ensure reliable, maintainable products.
AgileContinuous IntegrationQuality
0 likes · 22 min read

This article explains what Test‑Driven Development (TDD) is, outlines its step‑by‑step workflow, reviews its historical origins, compares it with traditional testing, and discusses the key benefits and drawbacks to help teams decide whether to adopt TDD.
AgileProgramming Practicessoftware development
0 likes · 7 min read

This article provides a comprehensive overview of Test‑Driven Development, explaining its principles, workflow, relationship to acceptance testing and traditional testing, its impact on design and documentation, challenges in database development, integration with Agile Model‑Driven Development, common myths, adoption statistics, and a curated list of supporting tools.
AgileTDDsoftware engineering
0 likes · 20 min read

This article offers a practical, experience‑based overview of unit testing, explaining why it matters, what makes a good test, when to write or skip tests, who should write them, and how to structure them effectively for reliable software quality.
code robustnesssoftware engineeringsoftware quality
0 likes · 9 min read

This article explains how agile development—especially Scrum—and agile testing practices like continuous testing, TDD, automation, and continuous integration enable rapid iteration, higher product quality, and faster delivery in fast‑changing market environments.
AgileContinuous IntegrationScrum
0 likes · 11 min read

The Story Scenario Tree is presented as a practical tool that guides developers to apply simple design principles—defining tasks, external interfaces, and upfront test cases—to create isolated, high‑quality code that evolves healthily, with progress measured objectively and defects minimized across changes.
agile developmentcode isolationdevelopment practices
0 likes · 5 min read


DevOpsAug 24, 2017 · Fundamentals
This article explains Test‑Driven Development (TDD) by outlining its advantages, underlying principles, step‑by‑step workflow, core guidelines, testing techniques, and practical tips, helping developers adopt the practice efficiently with minimal cost.
Programming Practicessoftware testingtest-driven development
0 likes · 14 min read

The author reflects on three major challenges—staff turnover, project‑schedule control, and software‑quality improvement—and argues that mastering software‑engineering techniques, tooling, and domain knowledge is essential for effective technical team management.
Development Toolscode qualitydomain knowledge
0 likes · 17 min read

This tutorial walks through creating a simple REST API with POST, GET, PUT, and DELETE endpoints using Node.js, Express, MongoDB, and Mocha, demonstrating a test‑driven development workflow from writing tests to implementing passing code.
ExpressMongoDBNode.js
0 likes · 10 min read

This article explains the fundamentals of unit testing, compares it with integration testing and TDD, describes characteristics of good unit tests, shows a practical .NET example using XUnit, FluentAssertions and Moq, and offers architectural tips for writing test‑friendly code.
Continuous IntegrationMockcode testability
0 likes · 15 min read

This article explains the fundamentals of unit testing, compares it with integration testing and test‑driven development, describes what makes a good unit test, shows how to improve code testability, and provides concrete C# examples using XUnit, FluentAssertions, and Moq.
.NETC++Mocking
0 likes · 18 min read


21CTODec 22, 2015 · Fundamentals
This article outlines twelve practical techniques—including TDD, ATDD, CI, pair programming, code reviews, static analysis, coding standards, automation, refactoring, early demos, user testing, and team cohesion—that collectively raise software quality while reducing bugs and development costs.
Continuous Integrationautomationcode quality
0 likes · 8 min read


21CTONov 6, 2015 · Backend Development
This article explains why automated testing is essential for PHP developers, outlines the benefits of test-driven development, and reviews the most popular PHP testing frameworks—including PHPUnit, Codeception, Behat, PHPSpec, SimpleTest, Storyplayer, Peridot, Atoum, Kahlan, and Selenium—to help you choose the right tool.
CodeceptionPHPautomated testing
0 likes · 8 min read
