Our Client
A global enterprise in North America whose integration estate runs on MuleSoft.
At a Glance
A global enterprise in North America needed to put AI agents into core business processes without giving up the consistency, testing, and governance its integration estate depends on. SoftServe encoded the entire MuleSoft delivery lifecycle in Cursor — 13 project rules, 25 agent skills, 13 model-pinned subagents, and 11 slash commands — so that every API follows the same governed path. The team then used that platform to deliver Unified AI, a conversational business flow across CRM, IT service management, ERP, and collaboration systems: 12 components in 24 days, the full program in seven weeks instead of 12–14.
The Challenge
- Slow, manual delivery. Taking one API from design to production took about three to four weeks of hand-written specs, scaffolding, flows, tests, pipelines, and documentation.
- Inconsistent output. Naming, structure, logging, and error handling varied between developers, so reviews were spent on style instead of behavior.
- Governance as an afterthought. Tests, API policies, and CI/CD came late, making compliance hard to prove and releases hard to repeat.
- A new AI workload. A multi-agent business flow had to be designed, integrated, secured, and shipped quickly — on top of existing enterprise systems.
Why Cursor
The team did not want another code generator. They wanted a delivery platform where conventions, procedures, and approvals live next to the code and run the same way every time.
- Project Rules make integration conventions the source of truth, attached automatically to the files they govern.
- Agent Skills capture every SDLC step as a written procedure backed by deterministic scripts.
- Subagents split work into planner, worker, and validator roles, each pinned to the model that fits the task.
- Slash Commands give engineers one obvious entry point per stage.
- Agent mode with terminal access builds, validates, and tests inside the loop before anything reaches a human.
Cursor stopped being an editor for us and became the delivery line: every API goes through the same governed path from design to production.SoftServe
The Solution: Two cases, one delivery platform
Case 1 · MuleSoft AI SDLC in Cursor
Each stage is a slash command that runs an orchestrator skill, a model-pinned subagent, and deterministic scripts. State passes between stages through a session file, so every loop can be resumed, with fail-fast after three attempts. Agents orchestrate, scripts compute, humans approve.
Cross-platform (macOS, Linux, Windows) · six CI tools × four deployment targets · seven-policy governance catalog.
Case 2 · Unified AI, Delivered With Cursor in the Daily Loop
Employees complete an enterprise business process — here, a renewal — through a conversation. AI agents work across four enterprise system families, and every call carries the user’s own identity and scopes.
Cursor was used across the whole cycle: understanding the existing codebase, implementing flows, investigating and fixing defects from runtime logs, and keeping specs, runbooks, and documentation in line with the code.
Under the Hood: Exact Cursor Capabilities per SDLC Step
| Step | What the agent does | Cursor capability | Human control |
|---|---|---|---|
| Preflight | Checks toolchain, credentials, and repo settings; reports gaps | Slash command · Skill · Agent terminal | Engineer fixes gaps |
| API design | Authors the spec against the rules; validates in a fix-and-retry loop | Orchestrator skill · 6 subagents · Rules | Spec review; consent to publish |
| Scaffold | Generates a buildable project with one stub per operation | Slash command · Skill · scripts | Reviews structure |
| Implement | Splits requirements into units; worker builds, validator lints and checks acceptance | Planner / worker / validator subagents · multi-model | Approves plan; reviews diff |
| Test | Writes suites that mock every outbound call; loops until green | Orchestrator skill · 3 subagents · Rules | Reviews test intent |
| CI/CD | Renders pipeline for the chosen CI tool and target; PR template, code owners | Skill · templates (6 × 4) | Branch protection; prod promotion |
| Consume | Builds API collections and 5 environments from the spec | Subagent · Skill | Spot-checks |
| Document | Writes technical docs from a project scan in a fixed order | Skill · Rules | Reviews before publishing |
| Govern | Creates the API instance, reconciles policies, wires autodiscovery | Slash command · Skill · platform scripts | Chooses policies per environment |
| Operate | Reads runtime logs, finds root cause, proposes fix, updates runbooks | Skill · codebase context · Browser tool | Approves every fix |
The Toolkit in Numbers
- 13 Project Rules — conventions as source of truth
- 25 Agent Skills, incl. 3 orchestrators
- 13 Subagents, each pinned to a model
- 11 Slash Commands as SDLC entry points
- 40 Portable automation scripts
- 7 Ready-made API governance policies
Governance and Security Gates
- Validation before push — failing specs are never pushed; the fix loop stops after three attempts.
- Consent before publish — publishing to the asset catalog needs an explicit human request.
- Per-unit build and lint — every implementation unit must pass deterministic checks.
- Deterministic tests — every outbound call is mocked.
- Build once, promote the same artifact — stable versions from DEV to PROD.
- Secrets per environment, kept out of version control.
- Runtime governance — gateway policies and on-behalf-of access on every API and agent call.
Business Impact: Faster Delivery, With Governance Built In
Unified AI: Plan vs. Actual
The 12 services, agents, and broker were built in the first 24 days; the remaining weeks went to hardening, approval logic, and documentation.
API Delivery: Before vs. Now (Delivery-Team Estimate)
| Metric | Before | Now | Type |
|---|---|---|---|
| Unified AI delivery time | 12–14 weeks (plan) | 7 weeks | Measured vs plan |
| Services, AI agents, and broker built | — | 12 in 24 days | Measured |
| SDLC stages automated | 0 | 9 | Measured |
| Enterprise system families integrated | — | 4 | Measured |
| API design to production | ~3–4 weeks | 3–5 days | Team estimate |
| APIs delivered per month | ~2 | ~6 | Team estimate |
| Pipeline setup for a new application | Manual | ~1 hour | Team estimate |
- Time-to-market. New integrations reach production in days, so AI use cases ship while the need is current.
- Capacity. A 12–14-week program delivered in seven frees about five to seven weeks of team capacity.
- Compliance. Conventions, validation, tests, and policies are pipeline stages — governance is provable.
- Reuse. One pipeline served every Unified AI service; a new app is onboarded in about an hour.
Measured figures come from version-control history and the repository inventory (Oct. 9, 2026). Team estimates are reported by the delivery team and will be instrumented through CI telemetry in the next phase.
The Blueprint: How it Works
- Write the conventions first. Rules turned tribal knowledge into a source of truth. Output stopped varying between runs and between engineers.
- Agents orchestrate, scripts compute. Parsing, rendering, building, and platform calls live in portable scripts — results stay deterministic, agents stay auditable.
- Small units, tight loops. Planner, worker, and validator, one unit at a time, with build and lint on every step and fail-fast after three retries.
- Humans own the irreversible steps. Publishing, production promotion, and policy changes always need an explicit human decision.
- The right model for each job. Each subagent is pinned to a model: deep reasoning for planning and code, fast models for validation.
- Reuse by design. One toolkit serves every new application — onboarding takes about an hour, not a project.
Results
- 12 in 24 days: services, AI agents, and an agent broker built for the Unified AI business flow (achieved)
- 7 weeks to deliver Unified AI end to end, against an original estimate of 12–14 weeks (achieved)
- 9 stages of the integration SDLC automated, from API design to API governance (achieved)
- 3–5 days from API design to production, down from about 3–4 weeks (team estimate)
Cursor capabilities in use: Agent mode + terminal · Project Rules · Agent Skills · Subagents (model-pinned) · Slash Commands · Multi-model routing · Codebase context · Browser tool
What’s Next
- Test automation for Unified AI — run the test orchestrator across all services and agents.
- CI telemetry — track pass rate, lead time, and deployment frequency to turn estimates into measured metrics.
- Cursor Hooks as policy — enforce lint, secrets scanning, and validation automatically during agent sessions.
- Platform tools via MCP — expose design, deployment, and governance APIs to agents.
- Scale to more teams — package the toolkit for other SoftServe integration teams.
Why SoftServe
This is SoftServe’s AI-native SDLC in practice: AI embedded across the whole lifecycle with governance, rules, and measurable baselines; enablement that scales through training, certification, and embedded engineers; and end-to-end delivery from tool selection to production.
Bring a governed AI SDLC to your integration team
Talk to SoftServe about putting Cursor at the center of your delivery lifecycle — from API design to production, with your conventions, your gates, and your platforms. Reach out today.


