Tagged articles
TDD
95 articles · Page 1 of 1
This article exposes how unit test coverage metrics mislead management by counting executed code without verifying correctness, demonstrates with examples how tests lacking assertions create false confidence, explains Goodhart's Law in testing, warns that AI-generated tests amplify the problem by boosting coverage without ensuring quality, and advocates mutation testing and TDD to ensure tests actually catch bugs.
AI codingGoodhart's LawTDD
0 likes · 10 min read

This article analyzes Matt Pocock's 27-agent skill framework that imposes explicit exit criteria across eight development activities — from requirement clarification to retrospective — to prevent AI coding failures like misalignment, verbosity, broken code, and architectural decay.
AI codingTDDagent skills
0 likes · 15 min read


Geek LabsSep 24, 2026 · Artificial Intelligence
gentle-shell is a Pi extension that enforces engineering discipline on AI coding agents through scope-first changes, evidence trails, strict TDD, frozen reviews, and human approval — making every AI change auditable and controllable.
AI coding agentODDPi
0 likes · 10 min read

The author details seven integration pitfalls when combining OpenSpec's specification-driven development with Superpowers' disciplined TDD workflow, demonstrates a real Go microservice JWT authentication case, and provides a custom bridge Skill to automate spec-to-plan translation, dual review, and verification.
AI-assisted developmentGoJWT Authentication
0 likes · 29 min read

The article outlines seven counter-intuitive principles for maintaining code quality when using AI coding agents, arguing that faster AI generation demands stronger engineering discipline, automated quality gates over long prompts, context isolation via short-lived agents, human-defined architecture boundaries, iterative development over detailed planning, junior developers mastering fundamentals before directing agents, and adapting principle thresholds to AI workflows.
AI agentsCRAP analysisContext Management
0 likes · 10 min read

Matt Pocock identifies six failure modes in AI-assisted programming — misaligned intent, verbose but unclear output, unrunnable code, shallow module proliferation, cognitive overload, and disinvestment in system design — and prescribes strategic remedies like Grill Me questioning, ubiquitous language glossaries, TDD feedback loops, deep module design, interface-first delegation, and daily design investment to keep AI as a tactical executor under human strategic command.
AI codingDDDGrill Me
0 likes · 9 min read

The article argues that while AI can generate code rapidly, it amplifies bad code and technical debt, so solid fundamentals, architecture, and disciplined practices like TDD—applied judiciously—remain essential for maintainable software, with four typical AI coding failures and three practical collaboration models outlined.
AIDesignTDD
0 likes · 7 min read


Tech BeanAug 9, 2026 · Artificial Intelligence
The article introduces Spec‑Driven Development (SDD) as a disciplined approach to AI‑assisted coding, contrasting vague “vibe coding” with structured specifications, and details how the open‑source tools OpenSpec and Superpowers together enforce pre‑defined specs, multi‑agent isolation, TDD and code review to make AI output reliable, maintainable, and traceable for teams.
AI codingOpenSpecSuperpowers
0 likes · 11 min read

To adapt legacy order‑system development to AI‑generated code, the authors propose a five‑gate, spec‑driven workflow—demand clarification, technical design, TDD implementation, gate‑controlled review, and end‑to‑end telemetry—built on a five‑layer bottom‑up architecture that enforces stability, observability, and human‑validated safeguards.
AI codingObservabilityTDD
0 likes · 17 min read

A seasoned programmer explains how imposing strict testing constraints on AI code agents—through a TDD‑style workflow, a multi‑stage gauntlet, and reproducible evidence—lets him trust generated code without manually reviewing each line.
AI agentsTDDcode generation
0 likes · 7 min read

The article reviews Matt Pocock’s open‑source “Skills For Real Engineers” repository, explains the four common agent failure modes, details six concrete skills—writing‑great‑skills, codebase‑design, TDD, diagnosing‑bugs, improve‑codebase‑architecture, and prototype—along with their failure patterns, completion criteria, and immediately adoptable actions for teams.
AI codingTDDagent skills
0 likes · 21 min read

While many expect AI to instantly double coding speed, the article shows that without a solid engineering feedback loop projects falter; Matt Pocock’s open‑source .skills repository offers a markdown‑driven workflow—clarifying requirements, documenting decisions, applying TDD, diagnosing bugs, and maintaining architecture—guiding developers through a repeatable, context‑aware AI‑assisted development process.
AI programmingClaude CodeTDD
0 likes · 14 min read

The article explains why AI‑assisted coding fails without a solid engineering feedback loop, introduces Matt Pocock’s open‑source .claude/skills workflow, and provides a step‑by‑step guide—including requirement clarification, PRD generation, vertical task slicing, TDD, debugging and architecture upkeep—to create a reproducible AI programming environment.
AI codingClaude CodeMatt Pocock
0 likes · 15 min read

This tutorial shows how to replace one‑off prompts with a repeatable Loop Engineering workflow—task cards, clarification, task breakdown, TDD cycles, verification records, progress snapshots, and release checks—so AI‑generated code stays stable, testable, and easy to resume across development sessions.
AI codingLoop EngineeringPrompt engineering
0 likes · 17 min read

This article explains how applying the classic PDCA (Plan‑Do‑Check‑Act) loop and a Harness engineering layer can transform probabilistic AI code generators like Codex and Claude Code into deterministic, reliable delivery tools for software development, documentation, and automated testing.
AI developmentAutomation TestingHarness Engineering
0 likes · 30 min read

An analysis of five rounds of OpenSpec experiments shows that content rules in the instruction field work, but structural rules do not, and source‑code inspection reveals that the template field is the authoritative structure, explaining the failure and guiding a corrective redesign.
AI toolingLLMOpenSpec
0 likes · 12 min read

The article introduces Matt Pocock's open‑source "skills" collection for AI coding agents, shows how it embeds traditional engineering practices such as alignment, domain modeling, TDD, and architecture governance into reusable command sets, and walks through a complete partial‑refund feature implementation using these skills.
AI coding agentsPrompt engineeringSoftware engineering workflow
0 likes · 22 min read

In this fourth OpenSpec case study, the author refactors the home page layout by introducing a category‑based tab navigation skeleton that replaces a scrolling long list, detailing the exploration of four design options, the chosen implementation using React, TypeScript and Tailwind, and the full TDD‑driven development, testing, verification and archiving workflow.
Frontend ArchitectureOpenSpecReact
0 likes · 26 min read

The article critically examines the rapid rise of AI coding frameworks such as OpenSpec, Superpowers, GStack, GSD, and Agent Skills, exposing their hidden cognitive and token costs, comparing their core philosophies, and offering a principled strategy for selecting the right tool based on task scale.
AI codingTDDframework comparison
0 likes · 15 min read

The article walks through a disciplined Go development workflow—red‑green‑refactor—explaining how test‑driven design, table‑driven tests, minimal viable code, and Go‑specific tooling together produce robust, maintainable code while illustrating each step with concrete examples and code snippets.
GoTDDTable-Driven Tests
0 likes · 10 min read

This article walks through a three‑iteration, AI‑assisted TDD workflow that combines OpenSpec for spec management and Superpowers for disciplined implementation, detailing a six‑step process, concrete code snippets, performance metrics, known limitations, and practical tips for backend developers.
AI programmingNode.jsOpenSpec
0 likes · 29 min read

This guide shows how to create a custom OpenSpec schema that injects TDD discipline into an AI‑driven coding workflow using three injection points and a four‑layer overlay, demonstrates that the propose phase works as intended while the apply phase only partially enforces TDD, and provides step‑by‑step setup, code examples, comparisons, troubleshooting and best‑practice recommendations.
AI codingClaude CodeNode.js
0 likes · 25 min read

This article walks through a six‑step, AI‑augmented review‑driven development workflow—using Spec‑Kit commands, devil‑style iterative reviews, and TDD—to turn a simple "user login failure lock" requirement into a robust, well‑tested implementation while catching design flaws early.
SDDSpec KitTDD
0 likes · 16 min read

The article presents a step‑by‑step AI‑enhanced workflow for modernising legacy systems, explaining how OpenSpec’s spec‑driven requirement layer and Superpowers’ strict execution pipeline (brainstorming, isolated worktrees, TDD, code review) together resolve inaccurate demand understanding and uncontrolled code generation, with a concrete flash‑sale implementation and practical pitfalls.
AI codingLegacy ModernizationOpenSpec
0 likes · 20 min read

Superpowers is an open‑source Claude Code plugin that embeds a full software‑engineering pipeline—requirement clarification, design, development, testing, and two‑stage review—into AI‑assisted coding, using isolated sub‑agents and Git‑managed outputs to improve code quality and maintainability.
Git WorktreeSoftware engineering workflowSuperpowers
0 likes · 12 min read

Superpowers is an open‑source workflow system that equips AI coding agents like Claude Code, Codex, and OpenCode with composable skills, decision‑flow diagrams, and test‑driven development to automate best‑practice software engineering from brainstorming to code review.
AITDDautomation
0 likes · 13 min read

This article walks through Superpowers' disciplined 7‑stage workflow—starting with brainstorming, using Git worktrees, writing granular plans, automated sub‑agent development, strict TDD, mandatory code review, and final verification—demonstrated with a coupon‑redeem API implementation.
AI programmingGit worktreesSuperpowers
0 likes · 21 min read

The Superpowers + OpenSpec Team Skills library provides a set of workflow modules that guide AI‑assisted development through requirement clarification, design confirmation, change specification, implementation planning, TDD, and verification, ensuring disciplined, traceable, and reliable feature delivery for collaborative projects.
AI developmentOpenSpecSuperpowers
0 likes · 6 min read

Even after mastering Superpowers' three‑step flow, developers can still crash due to wrong execution mode, loose quality loops, or unfinished branches, so this guide provides a decision checklist, quality pipeline, Git worktree isolation, and a default recipe to reliably deliver medium‑to‑large changes.
Git WorktreeSuperpowersTDD
0 likes · 11 min read

Superpowers introduces a structured, Git‑worktree‑based AI development workflow that tackles plan deviation by combining brainstorming, automated planning, sub‑agent execution, mandatory TDD, and continuous back‑check, offering a practical alternative to simple plan modes and heavyweight frameworks.
AI developmentAI workflowGit Worktree
0 likes · 13 min read


o-ai.techMar 26, 2026 · Artificial Intelligence
Superpowers inserts a highly granular "writing‑plans" step between a finished spec and code generation to translate design into narrow, verifiable actions for agents, eliminating ambiguity, enforcing TDD granularity, and externalizing senior engineers' tacit execution knowledge.
AI agentsExecution PlanningTDD
0 likes · 13 min read


o-ai.techMar 26, 2026 · Artificial Intelligence
The article analyses the Superpowers repository, contrasting it with gstack and showing how Superpowers tightens AI agents' behavior by embedding classic engineering discipline—step‑by‑step planning, testing, verification and review—into the development pipeline rather than merely expanding the agents' capabilities.
AI agentsGstackTDD
0 likes · 12 min read

This article explains the Agentic Engineering paradigm, outlining its three pillars, team‑level strategy, a detailed five‑step AI‑powered TDD workflow, role‑specific action items, and the broader shift from coding to commanding software development.
AIAgentic engineeringDevOps
0 likes · 10 min read

This guide walks through ten practical techniques—startup lazy initialization, scoped component scanning, selective auto‑configuration, async processing, connection‑pool tuning, JPA batch settings, multi‑level caching, multi‑stage Docker builds, JVM container‑aware flags, Tomcat thread tuning, Resilience4j, observability stack, and TDD—to diagnose and eliminate performance bottlenecks in Spring Boot applications.
CachingDockerJava
0 likes · 12 min read

Superpowers, an open‑source tool with over 29,300 stars, equips Claude Code with a full engineering workflow—brainstorming, planning, TDD, and task decomposition—so AI‑generated code follows disciplined software practices, dramatically reducing bugs and rework for developers.
AIClaudeSuperpowers
0 likes · 6 min read

This article shares Meituan’s practical approach to controlling the quality of AI‑generated code by using three strategies—unit‑test validation, safety‑net protection for legacy code, and a TDD‑driven workflow—illustrated with real Java examples and detailed test cases.
AI codingJavaTDD
0 likes · 27 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

In just three weeks, I single‑handedly created a production‑grade Retrieval‑Augmented Generation (RAG) API with FastAPI, leveraging Cursor and Claude Code to automate coding, testing, and deployment, and I share practical insights on AI‑assisted development, high cohesion‑low coupling design, TDD, git worktree parallelism, and agent orchestration.
AI codingFastAPIGit Worktree
0 likes · 19 min read

This article explores modern PHP practices that move error handling from runtime try‑catch blocks to proactive strategies such as static analysis, contract programming, attribute‑based validation, and test‑driven development, showing how to build more reliable and maintainable backend applications.
ContractsPHPTDD
0 likes · 5 min read

The article defines good code as functional and easy to modify, explains why focusing on maintainability and simplicity beats fast but fragile development, lists common signs of bad code, and offers concrete practices like small modules, clear naming, and test‑driven development to boost productivity.
Best PracticesTDDcode quality
0 likes · 4 min read

This article reviews and compares three AI code editors—Trae, Cursor, and Augment—detailing personal usage experiences, performance, feature differences, cost, integration with MCP tools, suitable scenarios for solo entrepreneurs versus professional developers, and practical tips for improving workflow with AI assistance.
AI code editorMCPProductivity
0 likes · 9 min read

This article outlines ten essential practices for testers in agile projects, covering early requirement involvement, test strategy creation, CI/CD integration, collaboration, TDD/BDD adoption, exploratory and performance testing, regression, continuous improvement, and knowledge sharing to ensure high‑quality software delivery.
Agile TestingBDDCI/CD
0 likes · 5 min read

In this detailed recap of a live session, the author shares personal experiences, compares six AI-powered coding assistants—including Trae, Cursor, and Augment—evaluates their speed, features, costs, and MCP support, and offers practical advice on tool selection, project workflow, and productivity techniques for developers.
AI coding toolsCode AssistantsMCP
0 likes · 12 min read

This article explains the importance of clean code in team development and walks through practical guidelines for naming, class design, function design, and testing, illustrating each principle with concrete Java examples, refactorings, and best‑practice recommendations.
Clean CodeTDDclass design
0 likes · 15 min read

The article explains why clean, well‑structured code matters for team productivity, covering naming, class design, function design, SOLID principles, testing practices such as TDD and the FIRST rule, and shows how tools like SonarLint can help maintain code quality.
Clean CodeSOLIDTDD
0 likes · 17 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

Test‑Driven Development (TDD) and Behavior‑Driven Development (BDD) are software development approaches that start with writing tests or user stories, outlining core steps, advantages, disadvantages, and offering guidance on selecting the appropriate method based on project requirements, team expertise, and business communication needs.
AgileBDDTDD
0 likes · 5 min read


DevOpsAug 4, 2024 · Fundamentals
This article explains the concepts of Test‑Driven Development (TDD), Unit Test‑Driven Development (UTDD), Acceptance Test‑Driven Development (ATDD) and Behavior‑Driven Development (BDD), discusses why TDD is not dead, compares the three approaches, and provides a step‑by‑step Java implementation with code samples, testing workflow, and refactoring guidance.
ATDDBDDJava
0 likes · 14 min read

The article reviews the history of China's IT industry over the past eighteen years, exposing how government policies, CMM certifications, and superficial agile practices have led to chronic software quality and delivery problems, and argues that only solid fundamentals such as extreme programming, TDD, and deliberate practice can truly improve software development.
AgileCMMContinuous Integration
0 likes · 25 min read

This guide explains why clean code matters, outlines practical naming conventions, class design principles, function structuring rules, and testing strategies—including TDD, the FIRST criteria, and automated test generation—to help developers write maintainable, readable, and high‑quality software.
Clean CodeSOLID principlesTDD
0 likes · 16 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

This guide introduces PHPUnit for PHP, explains how to install and configure it with Composer, and demonstrates common assertions such as assertEquals, assertNotEmpty, assertFalse, assertIsNumeric, and assertSame through practical real-world code examples.
PHPTDDassertions
0 likes · 5 min read

This guide introduces front‑end unit testing with Jest, explaining TDD and BDD concepts, installation, writing simple and ES6/TypeScript tests, configuring coverage, using common matchers, and employing mock functions, timers, and module mocking to ensure reliable, maintainable code.
JestMockingTDD
0 likes · 14 min read

This article explains why maintaining clean, readable code is crucial for team productivity, covering the impact of messy code, practical guidelines for naming, class design, function structure, and testing practices such as TDD and the FIRST principles, all illustrated with real code examples.
Clean CodeTDDclass design
0 likes · 15 min read

This article explains why clean code matters, demonstrates how meaningful naming, single‑responsibility classes, well‑structured functions, and disciplined testing (TDD and the FIRST principles) improve readability, maintainability, and productivity, using concrete Java examples, refactorings, and step‑by‑step guidelines.
Clean CodeSingle ResponsibilityTDD
0 likes · 17 min read

This article explains why clean code is essential for productivity and business health, and provides practical guidelines on naming, class design, function design, and testing—including code examples, refactoring techniques, and quality‑checking tools—to help developers produce readable, maintainable, and extensible software.
Clean CodeTDDcode quality
0 likes · 14 min read

The article explores David Farley's decades‑long experience in software engineering, highlighting his early automation work, contributions to the Agile Manifesto, the principles of Continuous Delivery, critiques of traditional waterfall methods, and practical guidance on Test‑Driven Development and learning‑oriented development to deliver business value.
AgileContinuous DeliveryDavid Farley
0 likes · 7 min read

This article explores Test‑Driven Development (TDD), explaining its core concepts, common misconceptions, tool choices such as JUnit, Mockito and JaCoCo, and provides practical case studies including a simple calculator and layered architecture examples in both anemic and DDD models.
DDDJUnitJaCoCo
0 likes · 28 min read

This article explains the concepts of narrow and broad unit testing, the shift‑left and shift‑right testing strategies, compares Mike Cohn’s and Google’s test pyramids, discusses the limitations of unit testing, and shows how unit testing fits into traditional and agile development models.
AgileTDDTest Automation
0 likes · 10 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

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

This article explains front‑end engineering concepts, common pain points, and a systematic learning path for team leaders, illustrating how to build a component library with Vue, adopt standards, CI/CD, monorepo, and TDD to improve team efficiency.
CI/CDTDDcomponent-library
0 likes · 11 min read

This article explains software testing fundamentals, classifies test methods, outlines general testing principles, dives into front‑end testing types and popular frameworks, provides code snippets for a minimal test runner, and compares TDD and BDD approaches, offering a comprehensive guide for developers.
BDDFrontend TestingTDD
0 likes · 24 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 presents fifteen practical, actionable rules for Test‑Driven Development, explaining how disciplined short cycles, writing tests first, and avoiding production data can make TDD both effective and executable for developers.
Best PracticesTDDmethodology
0 likes · 3 min read

This article explains the importance of refactoring, identifies common code smells, introduces SOLID principles and design patterns, and provides practical techniques—including method extraction, guard clauses, polymorphism, and composition—to improve code readability, maintainability, and testability.
SOLIDTDDcode quality
0 likes · 44 min read

This article explains why continuous refactoring is essential for evolving projects, defines refactoring and its scales, lists common code smells and their impact, and presents practical techniques—including SOLID principles, design patterns, naming conventions, layering, and test‑driven development—to turn messy code into high‑quality, maintainable software.
SOLIDTDDcode quality
0 likes · 36 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


DevOpsMar 12, 2021 · Fundamentals
The article examines the debate over whether TDD is dead, clarifies its core concepts—including ATDD and UTDD—explores common misconceptions, outlines three implementation stages, and provides practical guidance for adopting test‑driven development effectively.
ATDDContinuous IntegrationTDD
0 likes · 17 min read

Gaode’s navigation service adopted test‑driven development using Google’s GTest to replace slow diff‑based checks with fast, lightweight unit tests, enabling incremental refactoring of legacy code, improving quality, handling data‑dependency challenges, and demonstrating that writing tests first clarifies requirements while adding minimal overhead.
C++TDDbackend development
0 likes · 9 min read

This article explores how Test‑Driven Development and Google Test can improve quality and enable incremental refactoring of a complex, legacy online navigation system by addressing the shortcomings of traditional diff‑based testing, introducing unit‑testing fundamentals, and sharing practical implementation details and lessons learned.
C++TDDgtest
0 likes · 10 min read

This article explores why unit testing is essential, how to conquer the psychological obstacles that prevent developers from writing tests, and provides practical methodologies such as TDD, BDD, the test pyramid, and the Fixture‑Scenario‑Case pattern with concrete Java examples.
BDDFixtureJava
0 likes · 21 min read

This article explains how unit testing goes beyond coverage metrics, showing that writing testable code improves design, performance, and robustness, and provides practical guidance on refactoring, mock usage, data‑driven tests, TDD, BDD, and agile development practices.
BDDMockingTDD
0 likes · 17 min read

This article outlines agile software development design strategies, covering practical agile design activities, underlying design philosophies, and how design fits throughout the entire agile lifecycle, emphasizing iterative modeling, test‑driven development, and the balance between documentation and flexibility.
DesignTDDmethodology
0 likes · 12 min read


DevOpsJul 15, 2020 · Fundamentals
The article uses a whimsical conversation between a developer and a testing deity to explore why testing is essential, how it functions as sampling, the limits of defect detection, and practical strategies such as TDD, continuous integration, and requirement control to improve software quality.
Continuous IntegrationRequirements ManagementTDD
0 likes · 16 min read

The author shares a first‑hand account of a newly launched backend project, explaining how strict coding standards, Groovy‑Java mixed development, and a pragmatic testing strategy—including limited unit testing, interface checks, and annotation‑based validation—enabled rapid bug resolution and a smooth release.
GroovyJavaTDD
0 likes · 4 min read


DevOpsJun 23, 2020 · Fundamentals
This article explains Test‑Driven Development (TDD) as an agile design methodology, outlines the mindset, requirement analysis, test‑first habits, refactoring and unit‑testing considerations, demonstrates the red‑green‑refactor workflow with examples, and discusses common difficulties and best‑practice tips.
TDDdevelopment practicesrefactoring
0 likes · 8 min read

This article walks through setting up a comprehensive testing workflow for a Node.js backend, covering Jest configuration, unit and integration tests with SuperTest, in‑memory MongoDB, login helpers, mocking, snapshot testing, coverage reporting, CI integration, and the adoption of TDD/BDD practices.
CIJestMongoDB
0 likes · 22 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


DevOpsJun 24, 2019 · Operations
The article argues that without Test‑Driven Development (TDD) or its extension ATDD, DevOps initiatives and continuous delivery pipelines lack reliable automated testing, making releases risky despite high code‑coverage metrics.
ATDDCI/CDContinuous Delivery
0 likes · 6 min read

This case study details how a user product center team applied the APD agile methodology and stream development practices—such as visual value streams, explicit process rules, WIP limits, bug‑board visualization, workflow management, and an evolved TDD approach—to double throughput, cut delivery cycles by 60%, and reduce monthly bugs from 50 to 2, demonstrating measurable R&D efficiency gains.
APDAgileMetrics
0 likes · 7 min read

This article outlines thirteen common software testing antipatterns—from unstable or slow tests and manual test execution to treating test code as second‑class citizens and misusing TDD—explaining their negative impacts and offering practical guidance on building reliable, automated test suites.
CI/CDTDDTest Automation
0 likes · 14 min read


ITPUBJul 18, 2018 · Fundamentals
This article explores the philosophy of clean code, emphasizing disciplined design, clear domain language, realistic estimation, collaborative system modeling, and test‑first development to produce maintainable, efficient software that meets client needs while avoiding unnecessary complexity.
Clean CodeTDDestimation
0 likes · 13 min read


21CTOJul 5, 2018 · Fundamentals
This reflective essay examines how strict adherence to clean‑code principles, TDD, and SOLID can clash with personal well‑being and team dynamics, urging developers to consider empathy, context, and real‑world constraints when applying coding standards.
Clean CodeTDDsoftware craftsmanship
0 likes · 6 min read


DevOpsOct 22, 2017 · Fundamentals
The article uses the hammer metaphor to critique treating agile methods as a one‑size‑fits‑all tool, illustrating common misunderstandings through dialogues about user stories, estimation, TDD, pair programming, Kanban, Scrum, SAFe, and continuous delivery, and urging thoughtful adoption.
AgileScrumTDD
0 likes · 5 min read

This article explains the fundamentals of unit testing, including its importance, various test types, tool categories, implementation principles, hooks, best‑practice guidelines, and introduces the Jest JavaScript testing framework with installation steps, features, and example test scripts for both synchronous and asynchronous code.
BDDJavaScriptJest
0 likes · 9 min read


21CTOSep 3, 2017 · Frontend Development
This article examines why JavaScript developers experience fatigue, explains that software exists to reduce costs and increase revenue, and offers practical strategies—such as mastering fundamentals, selective tool use, and test‑driven development—to help engineers stay productive and focused on solving real business problems.
JS fatigueJavaScriptProductivity
0 likes · 18 min read

This article explores the root causes of JavaScript fatigue, emphasizing that software exists to solve business problems, not to please developers, and offers practical advice on focusing on fundamentals, reducing unnecessary tools, applying TDD, and treating software development like city planning to improve efficiency and value.
TDDsoftware engineeringtool fatigue
0 likes · 20 min read

The article outlines how test strategy, risk‑based testing, automation, TDD, defect‑location tools, CI/CD and agile practices can collectively boost development efficiency, reduce waste, and enhance product quality throughout the software delivery lifecycle.
CI/CDEfficiencyTDD
0 likes · 11 min read

This article explains why test cases are essential for high‑quality, maintainable code, compares TDD and BDD agile models, and introduces key frontend testing tools such as Mocha, Should.js, Nock, Istanbul, and mochawesome with practical usage examples.
BDDFrontend TestingTDD
0 likes · 6 min read

This guide explains why test cases are essential, compares TDD and BDD agile approaches, and introduces key frontend testing tools—including Mocha for test suites, Should for assertions, Nock for HTTP mocking, and Istanbul for coverage—while providing code examples and best‑practice recommendations for writing maintainable, high‑quality tests.
BDDFrontend DevelopmentJavaScript
0 likes · 8 min read


21CTOApr 27, 2016 · Mobile Development
This article shares practical experiences and best practices for Android unit testing, covering why testing matters, simple test structures, mocking with Mockito, dependency injection via Dagger2, using Robolectric, CI integration, common pitfalls, and a detailed checkout flow example.
AndroidCIDagger2
0 likes · 25 min read

Front‑end developer Xiao Ming discovers how unit testing with TDD/BDD, Mocha, and various assertion libraries can ensure reliable Node.js deployments, prevent regressions, and enable confident refactoring, while also learning to measure coverage with Istanbul.
BDDNode.jsTDD
0 likes · 7 min read
