DEV Community: luc

AI agents are becoming part of the development team.

luc — Fri, 18 Sep 2026 03:27:44 +0000

The interesting question is how we make them actually collaborate with developers.

With Sharkly.ai, an AI agent can be assigned tasks within a project, work on defined pieces of the workflow, and provide progress updates alongside human teammates.

Developers can focus on architecture, code quality, and decisions while agents handle repetitive or well-defined work.

Instead of AI as another tool, think AI as a teammate in the workflow.

How would you integrate an AI agent into your development team?

https://sharkly.ai/

How Humans and AI Agents Can Work Together

luc — Thu, 17 Sep 2026 09:49:17 +0000

AI agents are becoming part of the development workflow, but the real opportunity may be using them as teammates rather than standalone assistants.

With Sharkly.ai, developers can work with AI agents directly inside project workflows: assign tasks to agents, track progress, manage projects, and let agents handle repetitive work while humans focus on architecture, context, and decisions.

The goal isn’t to remove developers from the workflow — it’s to give them AI teammates that can contribute to the work.

How are you currently using AI agents in your development projects?

https://sharkly.ai/

When Does It Make Sense to Move Beyond Postman?

luc — Mon, 07 Sep 2026 11:23:46 +0000

Postman is still a great tool for testing APIs, but I’ve started wondering if an API client is enough for a modern development workflow.

As projects grow, we often need to:

Run API tests in CI/CD
Manage multiple environments
Keep API documentation in sync
Share test scenarios between developers and QA
Move from manual testing to repeatable workflows

That’s what led me to explore Apidog as a possible Postman alternative.

What I find interesting is that it combines API design, testing, documentation, mocking, and automation instead of treating them as separate workflows.

I know tools like Bruno, Insomnia, and Hoppscotch are also popular alternatives, so I’m curious what other developers here prefer.

Are you still using Postman, or have you moved to something else?

What If AI Agents Were Treated Like Real Teammates?

luc — Tue, 01 Sep 2026 09:11:35 +0000

AI agents are getting much better at executing tasks, but I think we're still using them like tools.

What happens if we start treating them more like actual teammates?

A human could assign a task, an AI agent could work on it, post updates, ask for clarification when blocked, and hand the result back for human review.

That requires more than an AI chatbot. You need shared context, task ownership, progress tracking, and clear human-agent handoffs.

I've been exploring this idea with Sharkly, a project management platform where AI agents can participate in the same workflow as human teammates.

https://sharkly.ai/

I'm curious how other developers are approaching this.

Would you rather have AI agents as assistants you interact with, or as actual members of your project team?

AI Agents Can Code. But Who Manages the Work?

luc — Thu, 27 Aug 2026 09:03:03 +0000

AI coding agents are getting surprisingly good at completing individual tasks.

But once you have multiple agents working on a real project, a new problem appears: coordination.

Who owns the task?
What is already being worked on?
What needs human review?
Where is an agent blocked?

I’ve been exploring Sharkly around this idea: treating AI agents as actual participants in the project workflow, alongside human teammates.

It feels like the next step after simply adding AI to development tools.

How are you currently managing work across multiple AI agents?

What Should an API Governance Tool Actually Check?

luc — Wed, 19 Aug 2026 06:29:01 +0000

API governance sounds straightforward until an organization has dozens or hundreds of APIs.

At that point, having a style guide isn't enough.

Someone needs to make sure APIs actually follow the rules.

I've been thinking about what an API governance tool should realistically check without turning governance into another bottleneck for developers.

For me, the useful checks fall into a few categories.

API Design Standards

The first layer is consistency.

For example:

Naming conventions
HTTP methods
Status codes
Pagination
Error formats
Versioning
Required OpenAPI fields

These are relatively easy to automate when the API contract is described with OpenAPI.

Security Checks

Governance should also catch obvious security problems before an API reaches production.

Things like:

Missing authentication
Weak authentication schemes
Exposed secrets
Insecure endpoints
Missing security requirements

Secret scanning seems particularly useful here because accidentally committing credentials is the kind of problem that should ideally be caught automatically.

Compliance

This is where governance becomes more organization-specific.

A company may have rules such as:

Every external endpoint must require authentication.

Or:

Every production API must include rate-limiting information.

Instead of relying on developers remembering these rules, an automated governance check can enforce them consistently.

Documentation Quality

An API can technically work while still being difficult to consume.

I'd like governance tooling to be able to detect things such as:

Missing endpoint descriptions
Missing parameter descriptions
Missing request examples
Missing response examples
Undocumented error responses

Documentation completeness seems like an underrated part of API governance.

Access Control

Governance isn't only about the API definition.

Once multiple teams are working together, organizations also need to control who can access, modify, publish, or administer APIs.

This is where things like RBAC, SSO, and user provisioning become relevant.

Auditability

Finally, there needs to be some way to answer:

Who changed what, and when?

Audit logs become increasingly important once APIs are shared across multiple teams.

Without them, investigating an unexpected API change can become surprisingly difficult.

So What Makes a Good API Governance Tool?

I don't think the answer is simply "more rules."

The best governance workflow should catch important problems early, ideally while developers are designing or reviewing an API rather than after deployment.

A useful workflow might look like:

API Design
↓
OpenAPI Validation
↓
Security Checks
↓
Compliance Checks
↓
Documentation Check
↓
Review
↓
Deployment

I've been looking at how platforms such as Apidog approach this by combining governance checks with the broader API development workflow, including RBAC, secret scanning, endpoint compliance, documentation completeness, and audit logs.

What I'm still wondering is how much governance should actually be automated.

For those managing APIs at scale, which governance checks have provided the most value?

And which checks ended up creating more friction than they were worth?

Git-Native API Workspace: A Practical Workflow for API Teams

luc — Tue, 18 Aug 2026 03:03:52 +0000

Most development teams already use Git for application code, infrastructure, and CI/CD.

But API development is often split across several places: an OpenAPI file in a repository, tests in another tool, documentation somewhere else, and API design happening in a separate workspace.

I've been experimenting with a different approach: treating the API contract as a first-class Git artifact.

What Does Git-Native API Development Mean?

The basic idea is simple:

The OpenAPI specification lives in Git and follows the same workflow as the rest of the codebase.

Instead of:

API design → export → Git → implementation → documentation

the workflow becomes:

OpenAPI → Git branch → review → validation → implementation → CI/CD

This gives the API contract the same history, review process, and traceability as application code.

Why Put the API Contract in Git?

There are a few practical advantages.

Pull request reviews

An API change can be reviewed directly in a pull request.

A reviewer can see when a required field was added, when a response schema changed, or when a new endpoint was introduced.

Version history

Git provides a complete history of API changes.

You can answer questions such as:

When was this endpoint introduced?
Who changed this response?
When did this parameter become required?
Which commit introduced the breaking change?

CI validation

Once the OpenAPI specification is in Git, CI can validate it automatically.

For example:

Pull Request
↓
OpenAPI lint
↓
Breaking-change check
↓
API tests
↓
Documentation

This makes API quality checks part of the development process rather than a manual step.

One source of truth

The biggest benefit is avoiding multiple versions of the API contract.

The repository contains the specification that the team actually reviews and ships.

Documentation, mocks, tests, and generated clients can then be derived from that contract.

Where Does a Git-Native API Workspace Fit?

There is still a problem with a purely Git-based workflow.

Editing large OpenAPI YAML files manually isn't always the best developer experience.

This is where a git-native API workspace becomes interesting.

You can have a visual API design environment while keeping Git as the source of truth.

I've been experimenting with Apidog's Spec-first workflow for this reason.

The OpenAPI specification remains in the Git repository, while the API workspace provides a visual environment for designing and working with the specification.

The important part for me is that Git doesn't become an export destination.

It remains the source of truth.

A Workflow I Would Actually Use

For a team starting a new API, I'd consider something like:

Step 1: Create the OpenAPI contract

Start with the API design before implementation.

Step 2: Create a Git branch
git checkout -b feat/customer-api
Step 3: Update the OpenAPI specification

Define the endpoints, schemas, parameters, authentication, and responses.

Step 4: Open a pull request

Review the API contract before implementation begins.

Step 5: Run automated checks

CI can validate the OpenAPI specification and run API tests.

Step 6: Implement the API

Backend development happens against the agreed contract.

Step 7: Generate downstream artifacts

Documentation, mocks, clients, and other artifacts can be generated from the same specification.

The Interesting Part Isn't the Tool

For me, the most important concept isn't whether you use Apidog, a text editor, or another API platform.

It's where the source of truth lives.

If the API contract exists only inside a separate platform, developers may have to synchronize it with Git.

If the OpenAPI specification lives in Git, the API becomes part of the normal software development lifecycle.

That's the idea behind a git-native API workspace that I find compelling.

What About Existing APIs?

This approach doesn't have to mean redesigning an entire API.

An existing OpenAPI specification can be moved into the repository and gradually incorporated into the development workflow.

The first goal could simply be:

API specification → Git → CI validation

Then testing, documentation, mocking, and code generation can be added progressively.

Final Thought

Git transformed how we collaborate on application code.

I think API contracts deserve the same treatment.

A Git-native workflow gives API teams:

Version history
Pull request reviews
Automated validation
Easier collaboration
Reproducible changes
A clear source of truth

The interesting question for me is whether an API workspace can provide a good visual development experience without taking the API contract away from Git.

Would you adopt a git-native API workspace for your team, or do you prefer keeping API design inside a dedicated platform?

Why I Replaced Postman with Apidog CLI for API Testing

luc — Tue, 04 Aug 2026 11:17:48 +0000

For years, Postman was my go-to tool for testing APIs. It was great for exploring endpoints and debugging requests during development.

As more of my workflow moved into CI/CD, I realized I needed something that worked just as well from the terminal as it did on my local machine.

That's when I started using Apidog CLI.

Why I Switched

My main requirements were simple:

Run API tests from the command line
Support multiple environments
Reuse the same test scenarios locally and in CI
Integrate easily with GitHub Actions
Avoid maintaining separate manual and automated test workflows
My Workflow

Instead of opening a GUI every time I change an endpoint, I can simply run:

apidog login
apidog run

The same tests I execute during development are the ones that run in our CI pipeline, which keeps everything consistent and reduces repetitive manual work.

What I Like About Apidog CLI
Fast terminal-based API testing
Easy integration with CI/CD
Environment management
Works well with OpenAPI-based projects
Keeps API validation close to the development workflow

Postman still has its place for exploring APIs, but for repeatable testing and automation, I've found a CLI-first approach much more efficient.

What about you? If you've moved away from Postman, what CLI tool are you using today, and what made you switch?

Top 10 CLI Tools for Developers in 2026

luc — Tue, 28 Jul 2026 18:44:18 +0000

Command-line tools are still an essential part of modern software development. They help developers automate repetitive tasks, manage projects, work with APIs, and integrate development workflows into CI/CD pipelines.

Here are 10 CLI tools worth knowing in 2026.

Git is the foundation of modern version control.

Developers use it to manage source code, create branches, track changes, and collaborate with teams.

git clone
git checkout -b feature-branch
git add .
git commit -m "Update feature"
git push

Docker CLI

Docker CLI makes it possible to build, run, and manage containers directly from the terminal.

docker build -t my-app .
docker run my-app

It's useful for creating consistent environments across development, testing, and production.

curl

curl is one of the simplest ways to interact with HTTP APIs from the command line.

curl https://api.example.com/users

It's useful for quickly testing endpoints, debugging requests, and working with web services.

jq is a command-line JSON processor that works particularly well with API responses.

For example:

curl https://api.example.com/users | jq '.[] | .name'

It makes it much easier to filter and process JSON data directly from the terminal.

kubectl

kubectl is the standard CLI for managing Kubernetes clusters.

Developers and DevOps teams can use it to inspect resources, manage workloads, and troubleshoot applications.

kubectl get pods
kubectl get services
kubectl logs

HTTPie

HTTPie provides a cleaner and more developer-friendly command-line interface for interacting with HTTP services.

It's useful for exploring APIs, debugging requests, and testing endpoints without opening a GUI tool.

Hurl

Hurl allows developers to define HTTP requests and expected responses in plain-text files.

This makes it useful for repeatable HTTP testing and automated workflows, especially when tests need to run in CI/CD pipelines.

Apidog CLI

Apidog CLI is an option for teams that want to integrate API testing into their command-line workflows.

It allows API test scenarios to be executed from the terminal and can be incorporated into automated development and CI/CD pipelines.

For example:

apidog login
apidog run

This can help teams run API validation as part of their existing development and deployment workflows.

GitHub CLI

GitHub CLI (gh) brings GitHub functionality directly into the terminal.

Developers can manage repositories, issues, pull requests, and GitHub Actions without constantly switching between the terminal and browser.

gh repo clone owner/repository
gh pr create
gh issue list

Terraform CLI

Terraform CLI is widely used for infrastructure as code.

It allows developers and DevOps teams to define and manage infrastructure using configuration files.

terraform init
terraform plan
terraform apply

It's particularly useful for automating cloud infrastructure and maintaining consistent environments.

Final Thoughts

CLI tools remain an important part of modern development workflows.

From Git and Docker to Kubernetes, API testing, and infrastructure automation, these tools help developers build workflows that are more repeatable and easier to integrate into CI/CD pipelines.

The best tools depend on your stack and workflow, but becoming comfortable with the command line can significantly improve your day-to-day development experience.

Best CLI Tools for API Linting in 2026: What Are Developers Using?

luc — Fri, 17 Jul 2026 15:31:59 +0000

As more teams adopt an API-first workflow, linting has become just as important as testing.

A well-defined OpenAPI specification helps prevent inconsistent naming, missing descriptions, invalid schemas, and breaking changes before they reach production.

Recently, our team started evaluating different CLI tools for API linting as part of our CI/CD pipeline.

During our research, this article was a useful resource:

https://apidog.com/blog/postman-cli-alternative/

What We Were Looking For

Our ideal CLI tool should be able to:

Validate OpenAPI specifications
Detect API design issues early
Integrate with GitHub Actions and other CI/CD platforms
Support automated quality checks
Fit naturally into a Git-based development workflow
Our Current Workflow

Instead of reviewing API specifications manually, we now run automated validation before merging changes.

We're also evaluating Apidog CLI because it combines API validation, testing, and automation into a single CLI workflow, reducing the need to switch between multiple tools.

Why CLI-Based Linting Matters

Adding API linting to the development pipeline has helped us:

Catch specification issues earlier
Keep API standards consistent across projects
Reduce review time during pull requests
Improve collaboration between frontend and backend teams
I'd Love to Hear Your Experience
Which CLI tool do you use for API linting?
Do you lint every pull request?
Are you using dedicated linters, or an all-in-one API platform?

I'm always interested in learning how other teams maintain high-quality API specifications.

When Does It Make Sense to Replace Redocly CLI? (2026)

luc — Mon, 13 Jul 2026 04:41:38 +0000

Redocly CLI has been a solid choice for OpenAPI validation, bundling, and documentation workflows. But as our projects have grown, we've started asking a different question:

Is a dedicated OpenAPI CLI still enough?

Our requirements today go beyond validating specifications. We also need to:

Run API tests from the command line
Support multiple environments
Integrate seamlessly with CI/CD
Keep API documentation in sync
Improve collaboration between developers and QA

That's what led us to evaluate Apidog as a possible Redocly CLI alternative.

One thing we've found interesting is the ability to combine API design, testing, documentation, and CLI automation in a single workflow instead of maintaining several separate tools.

I'm curious how other teams approach this.

Are you still using Redocly CLI?
If you've switched, what prompted the change?
Do you prefer specialized tools, or an all-in-one API platform?

I'd love to hear how your API workflow has evolved as your projects have grown.

Why More Teams Are Switching to API Testing CLIs in 2026

luc — Wed, 08 Jul 2026 05:58:24 +0000

For years, API testing has mostly been done through graphical tools. They're great for exploring APIs, but they become harder to manage as projects grow and automation becomes a priority.

Lately, we've been moving more of our API testing into the command line, and the workflow has been much easier to automate.

One tool we've been evaluating is Apidog CLI.

Why use a CLI instead of a GUI?

Running API tests from the command line offers several advantages:

Easy integration with CI/CD pipelines
Repeatable test execution
Better support for automation
Consistent testing across multiple environments
Faster feedback during deployments

Instead of opening a desktop application, tests become part of your build process.

Getting Started

Install Apidog CLI and verify the installation:

apidog --version

Authenticate:

apidog login

Run your API tests:

apidog run

Once everything is working locally, the same commands can be executed inside GitHub Actions, GitLab CI, Jenkins, or other automation platforms.

Where It Fits Best

We've found this approach particularly useful for:

OpenAPI-based projects
Microservices
Team environments with multiple APIs
Automated deployment pipelines

Keeping API validation in the same workflow as builds and deployments helps catch issues much earlier.

Final Thoughts

Moving API testing from a GUI into a CLI workflow has made our automation process much cleaner.

We're currently evaluating Apidog CLI because it combines command-line execution, environment management, and API testing in a way that fits modern development workflows.

I'm curious how other teams are approaching API testing in 2026. Are you relying on CLI tools, GUI tools, or a combination of both?