DEV Community: Govinda

Useful GitHub Copilot CLI Features

Govinda — Sat, 11 Apr 2026 03:51:01 +0000

GitHub Copilot CLI includes many helpful features that can make coding faster and easier.
Here are some of the most useful ones.

1. /tasks
This command shows the background jobs or agents that are currently running.

For example, if Copilot is using multiple models to review or refactor code, /tasks lets you see their progress and open a running session.

2. Autopilot mode
Autopilot mode means Copilot keeps working until the assigned tasks are finished.

3. Plugins
Plugins make Copilot CLI easier to extend. A plugin can package several features together, such as:

MCP servers
skills
custom instructions
custom agents

This makes things simpler for users. Instead of deciding whether they need an MCP server, a skill, or an agent, they can install one plugin and get everything they need.

4. plugin marketplace browse and plugin install
These commands work like an app store for Copilot CLI extensions.

You can browse available plugins in the marketplace, then install one with a command. After that, the plugin becomes available in your Copilot sessions.

5. Chronicle
Chronicle is one of the most interesting Copilot CLI features. It keeps a local record of your Copilot sessions in an SQLite database on your machine.

It can remember:

prompts you used
repeated patterns
past interactions

Two important Chronicle commands are:

chronicle improve
This reviews your past sessions and suggests ways to improve your Copilot instructions or repository instructions. For example, if you often remind Copilot how to format pull requests, it may suggest adding that as a permanent instruction.

chronicle tips
This gives personal tips on how you use Copilot. For example, if you often paste links and ask Copilot to analyze them, it may suggest using /research instead.

A key security point is that this history stays on your machine, inside your .copilot directory. It is not shared with your team or manager.

6. /research
This command is used for deeper analysis.

Instead of only responding to one pasted link, /research can search more widely across the web, GitHub, and similar repositories to provide better results.

7. Multiple models working in parallel
Copilot CLI can run multiple background agents using different models, such as:

Claude Opus
GPT-5.4
Gemini

Each model reviews the same codebase and gives its own recommendations. Then the main agent combines those results into one final report.

This is useful because different models may notice different problems. If several models find the same issue, that is a strong sign that the issue should be fixed.

8. Refactoring recommendations in tiers
After the background agents finish, Copilot can group the findings into tiers:

issues found by all models
issues found by two models
issues found by only one model

This helps you decide what to fix first.

9. Fleet mode
Fleet mode allows Copilot to split work across multiple sub-agents and run tasks in parallel.

Instead of handling one refactoring task at a time, it can work on several independent tasks at once.

10. /experimental show
This command shows preview features that are still being tested and are not yet generally available.

If you want early access to new features, you can turn on experimental mode and use this command to see what is available.

11. Future feature: remote session monitoring
It would allow users to check a running Copilot session remotely while away from their machine.

Copilot CLI is growing from a simple terminal assistant into a powerful multi-agent coding tool.

TestSprite Review: AI-Powered Testing Tool — Promise vs. Reality

Govinda — Fri, 12 Sep 2025 09:48:38 +0000

TestSprite positions itself as an AI-powered testing tool that promises to test your entire application without writing a single line of test code. After hands-on testing, here’s what you need to know before investing your time and money.

How TestSprite Works

The process is straightforward:

App Setup: Provide your website URL and basic login credentials

AI Exploration: TestSprite’s AI agent crawls your application to understand its functionality

Automatic Test Generation: The system creates test cases for discovered features

Test Execution: Watch the AI interact with your app like a real user, clicking buttons and filling forms

Two Usage Options

Web Interface (Beginner-Friendly)

Visit TestSprite’s website
Create a test by entering your app’s URL
Add authentication details (username/password)
Click “Start Testing” and monitor the automated process

IDE Integration
Install TestSprite directly in popular editors like Cursor or VS Code for a more integrated development experience.

Significant Limitations

Technical Constraints
Cloud-Only Execution:Tests run exclusively on TestSprite’s servers, making offline testing impossible

Accessibility Requirements: Your application must be publicly accessible, or you’ll need their tunneling feature

Local App Complications: Testing private/local applications requires additional MCP server setup

Corporate Network Issues: Firewalls may block access to TestSprite’s services

AI and Testing Challenges
Prompt Engineering Required: Despite promises of simplicity, you still need to understand effective prompt writing

Standards Misalignment: May not conform to company-specific testing standards and practices

Business Logic Gaps: AI often misses nuanced business rules and complex user workflows

Maintenance Overhead: Test configurations require updates whenever your application changes
Real-World Performance Issues

Based on practical testing experience:

False Positive Problem
The tool generates numerous false positives, significantly reducing confidence in test results. This defeats the primary purpose of automated testing — reliable validation of application functionality.

Cost Concerns
Multiple test runs consume credits quickly
The credit-based pricing model can become expensive for regular use
Cost per test may not justify the value, especially given accuracy issues
Bottom Line
While TestSprite’s concept of AI-powered testing is appealing, the current implementation falls short of expectations. The combination of frequent false positives, credit-based costs, and technical limitations makes it difficult to recommend for production use.

Consider TestSprite if:

You’re exploring AI testing tools and have budget for experimentation
Your application is simple and publicly accessible
You can tolerate false positives during initial testing phases
Look elsewhere if:

You need reliable, production-ready automated testing
Cost efficiency is a priority
Your application has complex business logic or user workflows
You require offline or local testing capabilities
The AI testing space is evolving rapidly, and while TestSprite shows potential, it’s not yet mature enough to replace traditional testing approaches for most development teams.

From Record & Playback to AI: Tools Don’t Fix Testing, Good Engineering Does

Govinda — Sun, 17 Aug 2025 11:24:04 +0000

In the early days, record and playback tools like QTP felt like magic, just hit record, click around, and an automated test script was ready. These tools worked for simple cases, but as test suites grew, they became hard to maintain. Problems like flaky tests, broken scripts, messy Excel files, and endless maintenance were common.

Teams who understood coding and good design patterns could use these tools much more effectively. The real issue wasn’t the tools themselves, but how people used them. If you just recorded tests without planning or structure, things would fall apart.

I saw a project with hundreds of QTP tests succeed only because the team built a strong framework and knew what they were doing.

Now, we’re seeing the same thing with AI. Some teams complain that AI can’t do basic math or that the output isn’t satisfactory, without realizing they aren’t providing proper prompts and context. The best teams use AI as a tool within a solid framework, for things like fixing broken locators, picking smarter tests, and speeding up triage.

In the end, tools don’t make testing easy, good engineering does. Teams who learn to use AI the right way will move faster and more reliably. Those who don’t will repeat the same mistakes as before.

Identifying and Removing Unused Dependencies in pom.xml

Govinda — Thu, 19 Dec 2024 17:44:48 +0000

When working with Maven projects, it’s important to keep your pom.xml file clean and efficient. Unused dependencies can slow down your builds, especially if you are using Docker, as it downloads all dependencies every time. Here's how you can identify and remove unused dependencies from your pom.xml.

Steps to Identify Unused Dependencies
Add the Maven Dependency Plugin to your pom.xml: Ensure that the Maven Dependency Plugin is included in your build plugins section.

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>3.1.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>analyze</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Run the Dependency Analysis: Execute the following Maven command to analyze your project and identify unused dependencies.

mvn dependency:analyze

Review the Output: The output will show you a list of dependencies that are declared in your pom.xml but are not used in your project. It will also show you dependencies that are used but not declared.

Warning: The plugin only detects statically linked dependencies and may incorrectly show dynamically linked dependencies as unused.

Improving Code Readability with Better Assertions in Java

Govinda — Thu, 19 Dec 2024 17:34:24 +0000

1. Understand the Difference between Assertions and Exceptions
Assertions and exceptions are two completely different things, and using assertions in place of exceptions is not recommended.

Exceptions:

Handle unexpected runtime events.
Disrupt the normal flow of a program.
Meant to help the program recover from unexpected situations

Assertions:

Used to test and verify code assumptions.
Help improve code readability, documentation, testing, and debugging.
Represent invariants or properties that must be true or false at specific code points

2. Use assertTrue and assertFalse for Boolean Checks
Bad Code

// Redundant comparison

assertTrue(user.isLoggedIn() == true);

// Complex, hard-to-read conditional assertion
assertTrue(user.hasPermission("read") != false);

The improved version is:

// Clean, direct boolean assertions, Clearly checks login status
assertTrue(user.isLoggedIn());

// Multiple boolean checks with clear intent
assertAll( () -> assertTrue(user.isAuthenticated(), "User should be authenticated"), () -> assertTrue(user.hasPermission("read"), "User should have read permission") );

3. Use assertNull and assertNotNull for Null Checks
This directly conveys the intention of the test, making the code more readable and easier to understand.

Bad Code
Using == null or != null can be less readable.

Assert.assertTrue(jsonPath.get("timestamp") != null, "Timestamp is miss");

The improved version is:

Although above code works, it can be made clearer and more expressive
by using assertNotNull

Assert.assertNotNull(jsonPath.get("timestamp"), "Timestamp is missing");

4. Use assertions to check preconditions and postconditions
Use assertions to check preconditions at the beginning of functions or methods to ensure that inputs are valid before executing the main logic.

In this example, the assertion checks a precondition (that x is positive) before proceeding with the rest of the method. If the assertion fails, it provides a clear error message.

public void testMethod(int x) {
    assert x > 0 : "x must be positive";
    System.out.println("x is positive");
}

5. Use Descriptive Assertion Messages
Always include a message in your assertions to explain what is being tested and why it might fail.

Avoid complex assertions that are hard to read and understand. Instead, break them down into smaller, simpler assertions.

Using Maven Wrapper to Ensure Consistent Maven Versions

Govinda — Thu, 19 Dec 2024 17:30:10 +0000

When working on a project, it’s important to ensure that everyone on your team is using the same version of Apache Maven. This helps avoid issues that can arise from different Maven versions. One easy way to achieve this is by using the Maven Wrapper.

What is Maven Wrapper?
Maven Wrapper is a tool that allows you to specify a particular Maven version for your project. It ensures that anyone who clones your project can build it with the exact same Maven version, without needing to install Maven manually.

How to Set Up Maven Wrapper
To set up Maven Wrapper for your project, follow these simple steps:

Open your terminal and navigate to your project directory.
Run the following command to create the Maven Wrapper configuration:

mvn wrapper:wrapper -Dmaven="3.9.9"

This command generates the necessary files and a mvnw command that will download and run Maven version 3.9.9.
Commit the generated files to your version control system (e.g., Git). This ensures that everyone who clones your project will have access to the Maven Wrapper.

Using Maven Wrapper
Once the Maven Wrapper is set up, you can use it to run Maven commands. Instead of using mvn, use ./mvnw (or mvnw.cmd on Windows). For example:

./mvnw clean install
This command will use the specified Maven version (3.9.9 in this case) to clean and build your project.

Benefits
Using Maven Wrapper offers several benefits for DevOps teams:

Consistency: Ensures that all team members and CI/CD pipelines use the same Maven version.
Ease of Setup: New team members can get started quickly without worrying about installing the correct Maven version.
Automation: Simplifies the setup of build environments, making it easier to automate builds and deployments.
Did you know that Maven Wrapper can also help you manage different Maven versions for different projects? If you work on multiple projects that require different Maven versions, Maven Wrapper makes it easy to switch between them without any hassle.