Can 10+ AI Agents Fully Automate API Development? Lessons from a Shire Experiment

Classic API Development Process

The technical implementation of an API is usually divided into the following sequential steps:

Design : Define the contract (Swagger/OpenAPI) and write developer‑focused documentation.

Implementation : Write controller and service code, perform manual functional checks, and add unit tests.

Integration & Coordination : Integrate with downstream services and conduct front‑back end joint debugging.

Testing : Execute functional, performance, and security tests.

Release : Deploy to production, update documentation, and monitor usage.

Typical Manual Challenges

API design requires business context and cannot be fully automated.

Documentation must reflect the specific domain and usage scenarios.

Bulk code generation introduces security and quality risks.

Generated code still needs human review and code‑style compliance.

Comprehensive testing (coverage, correctness) demands human oversight.

AI‑Assisted Agent Pack for API Development (Shire Language)

Ten+ local agents are organized to correspond to the classic stages, keeping a human‑in‑the‑loop for decision points.

Design Stage – 3 Agents

Requirement Agent : Calls a remote Dify service to extract design‑relevant information from internal requirement documents.

Swagger Generator : Produces an OpenAPI specification from the extracted requirements.

Mock Code & Service Generator : Generates WireMock stubs based on the Swagger file.

Shire provides a mock helper to start the generated mock service directly, e.g.:

mock("docs/mock_v0-stubs.json")

Development Stage – 3 Agents

Requirement‑Driven Code Generation : Refines Dify‑derived requirements and automatically updates controller and service classes.

API Test Execution : Generates HttpClient scripts (or Postman collections) that can be run manually or from the IDE.

Test Code Generation : Produces REST‑Assured test suites from the mock API definition.

Common Gradle tasks are wrapped in Shire helpers:

execute(":bootRun")   // launch the Spring Boot application
commit()               // stage changes
push()                 // push to remote repository

Testing Stage – 2 Logical Agents

Performance Testing : Supports Apache Benchmark ( ab), Locust (Python) and k6 (JavaScript) for load testing.

Functional Testing : Uses Playwright to run end‑to‑end API functional checks.

Legacy Documentation Generation – 2 Agents

SpringDoc OpenAPI : Adds the SpringDoc dependency via a Gradle patch and annotates controllers with Spring REST Docs.

Spring REST Docs : Adds the Spring REST Docs dependency and batch‑applies REST Docs annotations using the batch helper, e.g.:

batch("add-annotation-to-controller-test.shire")

Key Takeaways for AI‑Assisted API Development

Context‑Rich Integration : Embedding AI at each stage while feeding detailed design standards, business context, and coding guidelines maximizes usefulness.

Blockers Become Decision Points : Human‑AI collaboration transforms traditional bottlenecks into informed decisions rather than eliminating them.

Multi‑Round Automatic Verification : Generating complementary artifacts (production code, test code, mock services) with separate models enables cross‑validation and higher quality output.

Source code and demo project: https://github.com/shire-lang/shire-spring-java-demo