As 72% of software development teams now rely on AI code assistants (2026 Stack Overflow Developer Survey), validating code quality across multiple testing levels is more critical than ever. A 2025 IBM study found that fixing a bug found in production costs 15x more than fixing the same bug caught during unit testing, and 5x more than one caught during system testing.

If you have ever written a function that worked perfectly in isolation, only to break an entire user flow when deployed, you have seen the gap between unit testing and system testing firsthand. In this guide, we will break down the core differences between these two foundational testing levels, their use cases, best practices, and how they fit into a modern software delivery pipeline.

Table of Contents

1. What is Unit Testing?
2. What is System Testing?
3. Key Differences: Unit vs System Testing (Side-by-Side Comparison)
4. Core Similarities
5. How They Fit in the Testing Pyramid
6. Top Tools for Each Testing Level
7. 2026 Best Practices for Teams
8. FAQs
9. Final Thoughts

1. What is Unit Testing?

Definition

Unit testing is the lowest level of software testing, focused on validating individual units or components of an application in complete isolation. A unit is the smallest testable part of a codebase, typically a single function, method, or class. Developers write and run unit tests during active development, often before merging code to a shared repository.

Key Characteristics

• Isolation: Tests run without relying on external dependencies (databases, APIs, third-party services)
• Blazing fast execution: Most unit tests run in milliseconds, making them suitable for running on every code commit
• Heavily automated: Rarely run manually, integrated directly into CI/CD pipelines
• Relies on mocking/stubbing: Uses tools to simulate dependencies so tests only validate the unit itself
• Narrow scope: Targets a single specific functionality of one component

Who Performs It

Software developers write, run, and maintain unit tests as part of their day-to-day coding workflow.

Common Tools

• Java: JUnit 5
• Python: pytest, nose2
• C++: Google Test
• JavaScript/TypeScript: Mocha, Jest, Vitest
• .NET: NUnit, xUnit

Example Unit Test (Python + pytest)

This test validates a function that calculates order totals, with a mocked shipping API dependency:

# Arrange
from unittest.mock import Mock
import pytest
from order import calculate_total

def test_calculate_total_with_discount():
    # Mock external shipping API to avoid real calls
    mock_shipping_api = Mock()
    mock_shipping_api.calculate.return_value = 5.99

    # Act
    total = calculate_total(
        item_price=29.99,
        discount=10,
        shipping_client=mock_shipping_api
    )

    # Assert
    assert total == 32.98 # 29.99 * 0.9 + 5.99
    mock_shipping_api.calculate.assert_called_once()

Best Practices

• Follow the Arrange-Act-Assert pattern for all tests
• Test one specific behavior per test case
• Keep tests independent (no shared state between tests)
• Use descriptive test names (e.g., test_calculate_total_applies_10_percent_discount instead of test_total_1)
• Mock all external dependencies
• Run tests on every pull request to catch regressions early

Common Mistakes

• Testing multiple functionalities in a single test
• Forgetting to mock external dependencies, leading to slow, flaky tests
• Hardcoding test values instead of using constants or fixtures
• Skipping edge case testing (e.g., zero values, negative inputs, maximum limits)
• Over-relying on AI-generated unit tests without validating they cover intended behavior

2. What is System Testing?

Definition

System testing is a high-level black-box testing technique that evaluates the complete, integrated software system against formal business requirements. It tests the application as a single cohesive unit to verify that all components work together correctly for end users.

Key Characteristics

• End-to-end scope: Tests the full integrated stack, including frontend, backend, databases, APIs, and third-party integrations
• Production-like environment: Runs in a staging environment that mirrors production infrastructure as closely as possible
• Covers functional and non-functional requirements: Validates both that features work as intended, and that they meet performance, security, and usability standards
• Uses real-world user scenarios: Tests are based on actual user journeys, not internal code logic
• No knowledge of internal code required: Testers only need to understand expected behavior, not how the code is written

Common Types of System Testing

Who Performs It

Dedicated QA engineers, testing specialists, or SDETs (Software Development Engineers in Test) design, run, and maintain system tests.

Example System Test Scenario

For an e-commerce platform, a typical system test would validate the full checkout flow:

1. User creates an account and logs in
2. User searches for a product and adds it to their cart
3. User enters shipping and payment details
4. User submits the order and receives a confirmation email
5. Order appears in the admin dashboard and inventory is updated

Best Practices

• Create a formal test plan aligned with business requirements before starting testing
• Test both positive (expected success) and negative (expected failure) scenarios
• Document all test cases with clear steps, expected results, and priority levels
• Include edge case scenarios (e.g., 100+ items in cart, expired payment cards)
• Automate repetitive, high-priority flows to reduce manual testing effort

Common Mistakes

• Starting testing without clear, agreed-upon requirements
• Skipping non-functional testing, leading to performance outages in production
• Testing in an environment that does not match production (e.g., smaller server sizes, different database versions)
• Forgetting to test AI-powered features (e.g., recommendation engines, chatbots) for unexpected behavior
• Not documenting test results, making it hard to track recurring issues

3. Key Differences: Unit vs System Testing (Side-by-Side Comparison)

The table below summarizes the core differences between the two testing levels:

4. Core Similarities

While they serve very different purposes, unit and system testing share key foundational traits:

1. Both are mandatory testing levels in the standard Software Development Lifecycle (SDLC)
2. Both have the core goal of delivering high-quality, defect-free software to end users
3. Both can (and should) be automated for efficiency
4. Both require formal test planning and prioritization to be effective
5. Both identify defects that would otherwise cause issues for users in production

5. How They Fit in the Testing Pyramid

The testing pyramid is a widely adopted framework for balancing testing efforts to maximize efficiency and coverage:

• Base (Unit Tests): The largest portion of your test suite (70-80% of all tests). These are the fastest, cheapest, and most reliable tests, designed to catch 80% of bugs early in development.
• Middle (Integration Tests): Fewer than unit tests (15-20% of all tests), these validate that multiple units work together correctly.
• Top (System/End-to-End Tests): The smallest portion of your test suite (5-10% of all tests). These are the slowest, most expensive, and most prone to flakiness, so they should only be used to validate critical user journeys.

Common Anti-Pattern to Avoid

The “inverted testing pyramid” (more system tests than unit tests) leads to slow CI/CD pipelines, flaky test suites, and wasted engineering hours fixing tests that could have been avoided with proper unit testing.

6. Top Tools for Each Testing Level

Unit Testing Tools

• JUnit 5: The de facto standard for Java and JVM-based applications, with support for parameterized tests and nested test classes.
• pytest: The most popular Python testing framework, known for its simple syntax and robust fixture system.
• Vitest: Fast, lightweight testing framework for modern JavaScript/TypeScript projects, optimized for Vite and React/Vue/Svelte apps.
• Google Test: Open-source C++ testing framework with support for test discovery and death tests.

System Testing Tools

• Cypress 13+: Frontend end-to-end testing tool with native mobile testing support (added 2025) and AI-powered test flakiness detection.
• Selenium 4: Open-source cross-browser testing tool supporting all major browsers and programming languages.
• Postman 11: API testing tool with AI-generated test case functionality and native integration with CI/CD pipelines.
• JMeter 6: Open-source performance and load testing tool for validating system throughput under high traffic.
• LoadRunner Cloud: Enterprise-grade load testing tool for simulating millions of concurrent users.

7. 2026 Best Practices for Teams

1. Shift left testing: Integrate unit tests into your PR workflow to catch bugs before they reach QA. Run system tests automatically on every staging deployment.
2. Align test coverage with business risk: Prioritize unit tests for high-risk modules (payment processing, authentication) and system tests for high-traffic user journeys (checkout, login, signup).
3. Use AI responsibly: Leverage tools like GitHub Copilot to generate boilerplate unit tests, but always review them to ensure they validate intended behavior. Use AI tools like Testim to generate system test cases for common user flows.
4. Avoid over-testing: Do not write unit tests for trivial getters/setters, and do not write system tests for edge cases already covered at the unit level.
5. Unify test reporting: Use tools like Datadog Testing Monitoring to track test pass rates, execution time, and defect escape rates across both unit and system testing levels.

8. FAQs

Q: Can system testing replace unit testing?

A: No. System testing is far slower and more expensive to run and maintain, and it cannot pinpoint the root cause of bugs in individual code components. Catching bugs at the unit level reduces the workload for QA teams and speeds up release cycles.

Q: Do I need to automate both unit and system testing?

A: Yes. 100% of your unit tests should be automated, as they run on every code commit. For system testing, automate all repetitive, high-priority user flows, and reserve manual testing for exploratory testing and edge case scenarios.

Q: How much test coverage do I need?

A: Aim for 70-80% code coverage for core modules with unit tests. For system testing, aim for 100% coverage of critical user journeys, and 80% coverage of secondary flows.

9. Final Thoughts

Unit testing and system testing are not competing practices, they are complementary parts of a robust testing strategy. Unit tests catch bugs early in development, while system tests validate that your entire application works as expected for real users. By following the testing pyramid and shifting testing left, teams can reduce release cycles, cut down on production bugs, and deliver better software to their users.

References

1. Tutorialspoint: Software Testing Types
2. Software Testing Help: Unit Testing Guide
3. ISTQB Certified Tester Foundation Level (CTFL) 2025 Syllabus
4. 2026 Stack Overflow Developer Survey
5. IBM 2025 Cost of Software Defects Report

Jira owned the project management market. Asana, Monday, Basecamp, Trello, ClickUp all competed on features. Linear’s team walked in with fewer features than any of them and built a following among engineers. Linear is a worse product on paper. It does less. But the engineers who use it will fight you if you try to switch them back.

This pattern repeats across software. Products with fewer features take share in markets where the feature gap has collapsed to zero. The reason comes from game design.

The game is not the experience

Jesse Schell is a former Creative Director at Walt Disney Imagineering, Carnegie Mellon professor, and author of The Art of Game Design: A Book of Lenses (now in its third edition, 113 lenses drawing from psychology, architecture, music, anthropology, and film).

Lens #2: The Lens of Essential Experience. The game is not the experience. The game enables the experience, but it is not the experience. A game designer’s job is to identify the essential experience and design everything to support it. A feature list enables the product, but the user’s experience of it determines whether they stay.

Schell adds the concept of resonance: game themes that touch players do so by fulfilling their fantasies or affirming an idea the player holds to be true. Skyrim’s world is heavily scripted, but the fantasy of total freedom in a simpler world resonated enough that Bethesda sold 60 million copies on it. People buy Stardew Valley over games with 100x its budget because the pitch is the peace of farming minus the labor.

The Lens of Freedom: you don’t need to give the player true freedom, only the feeling of freedom. Notion works even though users rarely touch half its features. The feeling of having a system you built yourself is what keeps them.

Fantasies that won

If the experience runs on fantasy fulfillment, then every product that won a crowded market should have a clear fantasy behind it.

The competence fantasy. Vim and Neovim hold a devoted audience alongside VS Code because the difficulty is the appeal. Mastering Vim feels like beating a boss. The learning curve filters for people who want the fantasy of being an elite engineer. Vim users have a moment where they realize they’re editing text faster than anyone around them. Stack Overflow appeals to the same need: answer a question and the system tells you that you’re an expert. People chose Stack Overflow because it let them prove competence to strangers.

The belonging fantasy. Discord won gaming communities by making “your server” feel like “your guild.” Custom roles and custom emojis made each server feel owned. Slack won workplace communication by making “your workspace” feel like your team’s living room. They serve different markets but both won on the same fantasy: you belong to a group that has its own space.

The control fantasy. Linear’s team is taking Jira’s market by offering the absence of chaos. Calm UI and fast keyboard shortcuts. Engineers pick Linear because it makes them feel like their work is under control, even when it isn’t. Notion appeals to a related need: the workspace is the character sheet, the weekly planner is the quest log. Stripe’s team targets developers with the control fantasy. The API docs and the platform architecture tell the developer that they’re building real infrastructure.

The accumulation fantasy. VS Code’s appeal is power accumulation. Each extension you install and each keybinding you learn makes your editor do more than it did yesterday. GitHub delivers accumulation, and the comparison with GitLab and Bitbucket makes it visible. All three host code. GitHub is the one that turned contribution history into a persistent asset: the green squares, the profile page. GitLab and Bitbucket store your code. GitHub made your contribution history feel like a track record.

The expression fantasy. Figma’s appeal to designers is that the tool for designing things is itself a design game. Designers chose Figma because it let them express and iterate with other people watching. Excalidraw offers expression differently: the hand-drawn aesthetic says “this is a sketch, not a commitment.”

The reward fantasy. Schell’s Lens of Pleasure and Lens of Reward describe why certain game loops keep players coming back: the experience of earning something feels good independent of what you earned. Duolingo’s team built a productivity app around this loop. The streak counter and the XP bar pull you back. The guilt trip from the owl when you miss a day makes sure you don’t leave. Social media runs on the same loop (likes and notifications). Robinhood’s team brought it to investing: confetti on your first trade.

Not every product maps to a clean fantasy (chaos and destruction drive entire game genres but have few product analogues), but the exercise forces you to ask Schell’s question: what is the essential experience?

A lens from outside your discipline

None of the fantasies above came from the engineering discipline. They came from a game design textbook written by a former Disney Imagineer who also worked at IBM as a software engineer.

Grand strategy games train you to think about systems architecture. MMO guilds give you a framework for team dynamics and community products. A game design textbook reframes product-market fit in ways that product management books don’t cover.

The advice to specialize is about depth, and depth matters. But specialization advice usually comes with an implicit “and ignore everything else.” The engineer who reads game design or studies psychology has more mental models to pull from when the feature list runs out and the product needs a reason to exist.

Map your product to the fantasies above. If you can’t articulate which fantasy you offer that your competitors don’t, you’re competing on features, and features will converge over time. Schell’s Lens of Emotion asks: what emotions should the player feel, and are they feeling them? Next time you run a user test, ask what your users felt.

If you’ve ever tried building a token launchpad or a bonding curve on Solana, you already know the pain. You spend hours wrestling with complex SDKs, trying to figure out the precise math for a bonding curve, ensuring your token mints are actually “rug-proof,” and praying your Raydium CPMM pool creation doesn’t fail silently.

Most of the tools out there are heavy, monolithic, and full of dependencies you don’t need.

That’s why we built forgekit (@forgekit-labs) – a modular, zero-dependency toolkit that breaks down Solana token launches and Raydium infrastructure into pure, highly-focused functions.

In this tutorial, I’ll show you how to use forgekit to calculate a bonding curve, execute a secure token mint, and graduate a token to a Raydium CPMM pool in under 5 minutes.

What is forgekit?

forgekit is a collection of 8 single-purpose npm packages. Instead of forcing you to install a massive SDK, you only install exactly what you need:

• @forgekit-labs/curve: Pure bonding curve math (no network required).
• @forgekit-labs/token: Atomic token minting with built-in authority revocation.
• @forgekit-labs/launchpad: Raydium CPMM pool creation.
• @forgekit-labs/meta: Arweave upload via Turbo.
• …and more for LP splitting, fees, and v0 transaction building.

Let’s build.

Step 1: Install the Modules

For a standard bonding curve launch, you only need three modules. Let’s pull them down:

npm install @forgekit-labs/curve @forgekit-labs/token @forgekit-labs/launchpad

Step 2: Calculate the Bonding Curve

Bonding curves require precise math. Instead of writing custom logic to calculate market caps, progress, and thresholds, we use the pure functions from @forgekit-labs/curve.

Because this package is mathematically pure, it requires zero network calls and executes instantly.

import { calculateGraduationThreshold, getCurveProgress } from '@forgekit-labs/curve';

// Define your curve parameters
const startingPriceLamports = 1000; // Starting price in lamports
const targetSol = 85; // E.g., Graduate the curve when 85 SOL is raised

// Calculate exactly how many tokens need to be sold to hit the threshold
const thresholdTokens = calculateGraduationThreshold(startingPriceLamports, targetSol);

console.log(`To graduate, we need to sell ${thresholdTokens} tokens.`);

Step 3: The “Rug-Proof” Atomic Mint

One of the biggest issues with token launches is ensuring the creator actually revokes the Mint and Freeze authorities. If these aren’t revoked, the token isn’t safe.

@forgekit-labs/token handles this natively. It bundles the minting and authority revocation into a single, atomic transaction. If the revocation fails, the entire mint fails – guaranteeing safety.

import { createAtomicMintTx } from '@forgekit-labs/token';

// Build the transaction
const unsignedTx = await createAtomicMintTx({
  connection,
  creatorPubkey: userWallet.publicKey,
  name: "My Awesome Token",
  symbol: "MAT",
  metadataUri: "https://arweave.net/...", // Use @forgekit-labs/meta to get this!
  decimals: 6,
  totalSupply: 1_000_000_000,
});

// Send this unsigned v0 transaction to the frontend for the user to sign

Step 4: Graduate to Raydium CPMM

Once your curve hits its SOL threshold, it’s time to graduate. The token needs to migrate to a Raydium CPMM liquidity pool. Doing this manually involves massive boilerplate.

With @forgekit-labs/launchpad, it’s a single, idempotent call. It includes built-in validation and fee configuration.

import { createCpmmPool } from '@forgekit-labs/launchpad';

const graduationResult = await createCpmmPool({
  connection,
  baseMint: tokenAddress,
  quoteMint: "So11111111111111111111111111111111111111112", // Wrapped SOL
  baseAmount: thresholdTokens,
  quoteAmount: targetSol,
  // forgekit automatically handles idempotency and validation under the hood
});

console.log(`Graduation successful! Pool ID: ${graduationResult.poolAddress}`);

Conclusion

That’s it. No bloated SDKs, no guessing the math, and no worrying about whether your token authorities were actually revoked.

By splitting these complex actions into isolated, modular packages, @forgekit-labs gives you the exact tools you need to build a premium launchpad or trading terminal, without the headache.

Check out the code and start building:

• 🐙 GitHub: https://github.com/solDEv0/forgekit
• 📦 NPM: npm search @forgekit-labs

If you found this useful, drop a star on the repo and let me know what you’re building!

We’ve all been there.

You finish building a new project. It’s clean, it’s working, and it’s ready to ship.

But then comes the worst part: Writing the CI/CD pipeline.

You open Google, copy a 3-year-old GitHub Actions workflow from Stack Overflow, spend 45 minutes debugging YAML indentation errors, and realize you forgot to configure dependency caching or security scans.

I got tired of repeating this manual process, so I built a zero-config CLI tool to solve it once and for all: ciraft.

🔍 What is ciraft?

ciraft is a lightweight CLI utility that scans your codebase, auto-detects your programming languages, package managers, and container setups, and instantly generates a production-grade CI/CD pipeline in seconds.

Instead of writing YAML from scratch, you just run:

npx ciraft

🛠️ How It Works (Behind the Scenes)

When you run ciraft, it performs a local analysis of your project files:

Detects your package managers: npm, pnpm, yarn, pip, poetry, go, or cargo.
Scans for tests and linters: Jest, pytest, vitest, ruff, etc.
Looks for Docker configuration: Dockerfiles, multi-stage targets, and Compose configurations.
Applies security best practices: Sets strict permissions, sets up matrix builds, configures concurrency gates, and automatically appends a Trivy vulnerability scan for Docker images.
It then renders a optimized .github/workflows/ci.yml using pre-compiled templates.

⚡ Try It Right Now
You can run it via npx or install it directly using Homebrew:

bash

Install via Homebrew

brew install https://raw.githubusercontent.com/DhanushNehru/ciraft/main/Formula/ciraft.rb

# Scan and generate
ciraft

🤝 Let’s Collaborate (PRs Welcome!)

ciraft is 100% open-source, and I want to support every stack under the sun.

Currently, it supports Node.js, TypeScript, Python, Go, Rust, and Docker.

If you want to add support for a new language (like PHP, Java, Ruby, or Elixir) or a new CI provider (like GitLab CI or Jenkins), check out the repository! I have pre-written 30+ detailed GitHub Issues tagged with good first issue and hacktoberfest to help you get started.

👉 Check out the repository, drop a ⭐ if it saves you time, and let’s build this together: ciraft

💬 What’s the most annoying part of writing CI/CD pipelines for you? Let’s discuss in the comments below! 👇

The Problem We Were Actually Solving

We were tasked with creating a platform that would allow creators to sell digital products directly to their audience, bypassing traditional payment gateways that didn’t support African markets. PayPal, Stripe, Gumroad, and Payhip – the usual suspects – were all out of the question due to local restrictions and high fees. Our creators needed a solution that was both scalable and cost-effective.

We knew that building a custom payment system from scratch was a non-starter, given the sheer number of integrations and regulatory compliance requirements. Our only option was to choose a suitable platform that could support our unique needs.

What We Tried First (And Why It Failed)

Our initial approach was to use a popular headless e-commerce platform that promised flexibility and customization. We spent weeks integrating it with our existing infrastructure, only to discover that it was woefully inadequate for our use case. The platform’s payment processing fees were astronomical, and the transactional API was a black box that we couldn’t fully instrument. Our creators were pricing themselves out of the market, and we were hemorrhaging money on transaction fees.

What’s more, the platform’s documentation was a joke, and the community support was non-existent. We were on our own, trying to troubleshoot issues that we didn’t have the expertise to handle. It was a recipe for disaster.

The Architecture Decision

After months of searching, we finally found a suitable platform that checked all the right boxes. Mollie, a Dutch payment service provider, offered a fully-fledged payment gateway that supported multiple currencies, including the local Nigerian naira. Their API was robust, well-documented, and easy to integrate. We were able to hook up our creator’s products to Mollie’s payment flow with ease, and the fees were a fraction of what we were paying before.

But here’s the thing: Mollie wasn’t a traditional payment gateway. They didn’t have a sprawling front-end that we needed to integrate with. Instead, they provided a comprehensive backend API that we could use to create our own checkout flow. This requirement added a level of complexity to our platform, requiring us to build out a custom checkout experience from scratch.

What The Numbers Said After

After deploying Mollie to production, our creators saw a significant increase in sales and revenue. Our transaction fees plummeted, from 5.5% to 2.9%. But more importantly, our creators were now able to price their products competitively, knowing that they had a reliable payment partner.

According to our analytics, our creator’s average order value (AOV) increased by 25% after integrating with Mollie. This was a clear indication that our creators were finally able to capture value at the point of sale, thanks to Mollie’s reliable payment processing.

What I Would Do Differently

If I were to do it all over again, I’d make sure to involve our creators in the platform decision-making process from the get-go. We learned too late that they had specific pain points and requirements that we didn’t account for initially. By involving them in the decision-making process, we could have avoided some of the initial integration issues and gotten them on board with our platform design from day one.

Secondly, I’d invest more in API documentation and instrumentation. While Mollie’s API was excellent, we had to spend a significant amount of time instrumenting their API calls and monitoring our transaction flows. With better documentation and instrumentation, we could have avoided some of the issues we faced during the integration process.

The Problem We Were Actually Solving

When we first set out to optimize the Treasure Hunt Engine, our primary goal was to improve player engagement. We wanted to make the treasure hunt experience more challenging, rewarding, and generally more fun. We spent countless hours tweaking algorithms, experimenting with different game logic, and fine-tuning the UI. But as we delved deeper into the code, we realized that our changes were having an unintended consequence: the engine was becoming increasingly CPU-intensive.

What We Tried First (And Why It Failed)

Initially, we focused on optimizing the game logic, assuming that the engine’s performance was directly tied to the complexity of the rules. We implemented various caching mechanisms, parallelized expensive computations, and even rewrote the entire engine using a more efficient language. However, our efforts were largely ineffective, and the engine’s performance continued to suffer. We were baffled – why were our optimizations not having the desired effect?

The problem was that we were optimizing the wrong thing. The game logic was indeed complex, but the true bottleneck was the way we were loading the game world data into memory. The engine was creating a massive, densely packed graph of objects, which was causing the CPU to grind to a halt. We were treating the symptoms, not the cause.

The Architecture Decision

Around this time, we decided to revisit our architecture and make a fundamental change: we would offload the game world data to a separate process, using a message-passing interface to communicate between the engine and the data store. This would allow us to scale the data store independently of the engine, reducing the memory footprint and CPU load. We also introduced a caching layer to minimize the number of requests made to the data store.

What The Numbers Said After

After implementing the new architecture, we ran a series of benchmarking tests to measure the engine’s performance. The results were striking: our CPU usage had dropped by 30%, and the engine was now able to handle 50% more players without a noticeable increase in latency. The caching layer was also a huge success, reducing the number of requests made to the data store by 75%. We had finally broken through the performance bottleneck.

What I Would Do Differently

Looking back, I wish we had taken a more systematic approach to performance optimization. Instead of trying to optimize the game logic, we should have started by profiling the engine’s memory usage and identifying the source of the performance issue. We also should have considered the potential trade-offs of our architecture changes, such as the increased complexity of the message-passing interface.

In the end, our experience with the Treasure Hunt Engine taught us a valuable lesson: when optimizing performance, it’s essential to identify the root cause of the problem, rather than treating the symptoms. By taking a more careful and systematic approach, we can avoid the common pitfalls of premature optimization and achieve better results in the long run.

great_cto v2.17 – no more tambourine dance

If you’ve ever spent 20 minutes setting up Claude Code plugins before you could even start working – this update is for you.

One install, everything works.

Previously: install great_cto, then figure out that Superpowers and Beads are also needed, find the repos, clone them, enable them in settings, restart. Classic.

Now – one command:

npx great-cto install

Done. Superpowers and Beads install automatically as companion plugins. They land in ~/.claude/plugins/cache/local/, get enabled in settings.json, and are ready to work. If git is missing – great_cto gives a friendly hint instead of silently failing.

Jurisdiction-aware agents.

The new jurisdictions module detects the context of your project – EU, US, Canada, UK, Australia, and others – and automatically activates the right regulatory reviewer agents.

Working on a fintech product for European users? The EU reviewer turns on automatically. Building for the Canadian market? PIPEDA gets covered. No manual configuration, no trying to remember what applies where.

Eight jurisdictions are currently supported, and the list keeps growing.

llm-leash UI: 16 new features.

The board got a serious upgrade. The most useful ones:

• Cmd-K – global command palette for navigation.
• Issues subtab – all security and compliance findings in one place.
• Session timeline – visual history of what happened and when.
• Topology graph – shows agent dependencies. Useful when you have 5+ parallel agents.
• HITL diff – human-in-the-loop review of agent changes before they’re applied.
• OPA config – Open Policy Agent integration for compliance rules.
• SOC2 export – one-click audit trail for compliance officers.
• Rule comparison – compare policy versions side by side.

Companion plugins out of the box.

A bit more detail on how the Superpowers + Beads bundle works, since the architecture is non-obvious.

Superpowers – a methodology plugin. It gives Claude Code skills: /brainstorm, /write-plan, /execute-plan, code review workflow, TDD cycle, parallel agent execution. Without it, Claude acts on vibes. With it – on a structured plan.

Beads – a git-native task tracker. Tasks live as commits, survive session restarts, have dependencies and blockers. Claude creates and closes them autonomously as it works.

great_cto – the orchestration layer. It routes requests to the right agents, enforces reviewers based on archetype and jurisdiction, manages the agent pipeline.

Together: you describe what needs to be done, great_cto breaks it into a plan, Beads tracks it, Superpowers enforces methodology, the right reviewer agents plug in automatically.

TL;DR

npx great-cto install

• npm: https://www.npmjs.com/package/great-cto
• GitHub: https://github.com/avelikiy/great_cto

Feedback and PRs welcome.