TL;DR: Our engineering team ships features faster since we gave an artificial intelligence (AI) coding agent one shared cloud environment. It holds every repository, specs of the existing code, automatic quality gates and a live preview. Our knowledge-based authentication feature went from start to production in two weeks.
Our last major feature, knowledge-based authentication (KBA), went from start to production in two weeks. Under our old process, a feature that crossed this many modules took several sprints of coordination between teams.
The model did not make the difference. Neither did a clever prompt.
The gain came from giving our AI agent a proper place to work. That place is one cloud environment with every repository, every quality gate and a view of the running app, shared by the whole team.
This post covers what is inside that environment and what it changed about the way we work.
How did we build software before AI coding agents?
We built it the classic way, with module teams, sprints and hand offs. Our stack is .NET (Microsoft’s development platform) on the backend, with Vue and React on the frontend, across several repositories.
- Product writes a spec, and we plan it into a sprint.
- Engineering splits into module teams, each owning one area of the product.
- A feature that crosses modules goes to other teams as requirements for their own sprints.
- Everyone meets for a coordinated release.
The process was predictable and it protected quality. It was also slow. Every line went through an engineer’s hands, and every cross module change waited in someone else’s queue.
Why did AI in the editor hit a ceiling?
AI in the editor made each engineer quicker but left the team’s process as it was. We moved to BoldCreate IDE, an integrated development environment (IDE) with AI help inside the editor, and boilerplate and tests came faster.
- Context stopped at the laptop. Each engineer had a different checkout and setup, so the AI knew a single machine.
- The engineer was still the loop. A human ran the build and tests, read the failures and asked again.
- The process stayed the same. Sprints, hand offs and module boundaries stayed where they were.
We had faster typists, not a faster team.
What changed when we moved the agent to the cloud?
Every task now runs in its own cloud session, against one environment we set up once and everyone shares. We use BoldCreate Cloud Agent for this, from Syncfusion, BoldSign’s parent company.
- The agent sees the whole system. Every repository lives there, so a cross module change is one task.
- Setup happens once. Toolchains, packages and service settings live in the environment, so every machine gets the same result.
- Work runs in parallel. An engineer can start several tasks, step away and come back to finished branches.
We stopped treating AI as a pair programmer. We started treating it as a teammate with its own fully set up workstation.
What is inside the shared cloud environment?
The environment holds everything a session needs to build, run and check the real system on its own. Most of our effort went here, because an agent is only as good as the place it works in.
Every repository
The web app, backend services, shared libraries and our public API are all checked out in the session. The agent can follow a call from the screen to the database layer without anyone opening another project.
One time setup
Setup scripts install the .NET and Node toolchains, restore packages and configure each service. A fresh session gets to a working build with zero manual steps.
Specs for a brownfield codebase
This is the one we underestimated. Our product carries years of business rules across many modules. An agent dropped into that cold writes code that compiles but ignores how the system behaves. So we had the agent write detailed specs of our existing source: what each module does, how modules talk to each other and which rules they enforce. Every session starts from that map.
Project context and agent instructions
Every session starts from the project context. It holds what a senior engineer would tell a newcomer: how the solution is laid out, our conventions, which areas need a named person before anything changes, and the gotchas we learned the hard way. We keep it short and true, because it goes into every task whole. Operating instructions tell the agent how to work: one task per work item, a written spec with acceptance criteria a test or gate can check, a plan where every step names its test, and what to do when it gets stuck.
A harness that decides, so the agent does not have to
The heart of the setup is one rule: the agent may narrate, but it may not assert. "Tests pass", "this is covered", "no secrets" and "the frontend still works" are claims a gate measures, not claims the agent makes.
Before building, the agent declares which tests cover the change. The harness then builds with code analyzers on, runs exactly those tests, checks coverage on the changed lines, scans for secrets and vulnerable packages, and runs typecheck, lint and tests on the frontend when it changes. A backend change to an endpoint the frontend calls makes the agent trace and record every call site, and a gate checks each cited line exists. Gate results are pinned to a commit, and a task is done only when a passing result matches the latest one.
The effect is simple: nothing reaches a human reviewer on the agent's word alone.
See it running, without a local build
We set up the environment to tunnel the app running inside the cloud session out to the engineer as a live preview. No pulling the branch, no local build, no starting every service just to click through a feature. You open a link and use it. This removed one of the slowest steps in review.
How does a feature go from spec to merge?
The engineer now frames the work, steers the agent and owns the review, while the agent writes most of the code. A typical feature runs in six steps.
- Spec first. Each change starts as a task tied to a work item, with a spec and testable acceptance criteria.
- Plan and declare the tests. The agent proposes a plan, names the test for each step and declares those tests.
- Build in small steps. Backend and frontend change in the same session, with gates and a commit after each step.
- Gate the final commit. All gates run on the latest commit, and failures go back with the exact line or test.
- Try it live. The engineer opens the running feature through the live preview and uses it like a customer.
- Two reviews, then merge. A reviewer agent reads the diff and gate evidence, then an engineer reviews and merges.
Where does the engineer step in?
The engineer adjusts the plan before any code is written. Wrong turns are far cheaper to catch at the plan than in a diff.
The agent stops after three genuinely different attempts on the same gate. It records why and hands off. Being blocked is a valid outcome; spinning is not.
How did KBA reach production in two weeks?
One engineer owned KBA across every module, in one environment, with every gate run before review. Start to production took two weeks.
KBA asks signers to answer questions about themselves before they can sign. It touches the sending flow, the signing flow, our public API and the audit trail. In the old model, that meant several module teams and several sprints of coordination.
This time, the team clicked through the working feature in the live preview long before it reached staging.
| Aspect | Traditional process | AI in the IDE | Cloud agent |
|---|---|---|---|
| Who writes the code | Engineers | Engineers, with AI suggestions | The agent, steered by engineers |
| Cross module changes | Hand offs between team sprints | Still hand offs, one project at a time | One session, one pull request |
| Quality checks | After the fact, in automated builds and manual testing | Engineer runs tests and feeds back failures | Every gate, before review |
| Parallel work | One task per engineer | One task per engineer | Several tasks at once, each in its own session |
| Seeing the feature | Pull the branch and build locally | Pull the branch and build locally | Open a link |
The speed came from removing waits: for another team’s sprint, for a bug to be reproduced, for tests to run.
How did the cloud agent change our team?
Once one environment could build, test and preview the whole system, it became the standard way every engineer works. That shift made us rethink how we organize.
- Feature ownership replaced module ownership. An engineer now owns a feature end to end, wherever it lands in the code.
- Standards ship with the environment. We add a rule or gate once, and every session follows it from then on.
- Improvements compound. A sharper spec or a new gate improves every engineer’s next task at once.
Splitting work by module mostly created hand offs once an agent could change any module in one session. Our harness is versioned centrally and synced to every repository, and agents cannot change it from inside a task.
We are now rolling out this environment and harness across the whole engineering team as the one way we deliver features and fixes.
Which guardrails did we keep?
We kept every review and test step, because people use our software to sign legally binding documents. Going faster could not mean lowering the bar.
- Humans own the merge. Every change gets a human code review: the agent proposes and engineers approve.
- Gates stay as strict as they are. Lowering a threshold or skipping a test is off limits.
- Some decisions stay human. Scope, breaking interface and irreversible data changes go to a person as a written decision.
- Work survives the handoff. The spec, plan, impact and evidence live with the task and ship with the pull request.
- Agent changes take the same pipeline. Continuous integration (CI) still runs the full test suite on every change.
The gate settings are locked, and sensitive areas such as authentication need a named person to approve. While a decision waits, the agent keeps building whatever does not depend on the answer.
What would we tell a team making the same move?
Fix the environment before the prompts, and let measured checks decide what the agent claims. Here is the rest of what we would tell you over coffee.
- Fix the environment first. An agent needs what a new hire needs: a way to build, test and run your system from the environment alone.
- Generate specs first on a brownfield codebase. That map decides whether changes fit the code or fight it.
- Never take the agent’s word for it. When a tool can measure a claim, let a gate decide it.
- Keep the context short and true. A short project context in every task stays current; a long guide drifts.
- Put the running app one click away. Removing the local build from review saved more time than we expected.
What else did we learn?
Make “blocked” an acceptable answer. An agent that stops after three honest attempts and explains why is worth more than one that keeps trying.
Centralize, and let the harness carry the standards. One shared setup does the work of a hundred team announcements.
Where can you start with AI and eSignatures?
We are still early, and every improvement to the environment lands for the whole team at once. AI made our engineers faster in their editor, and it made our team faster once it had a real place to work.
- Start a 30-day free trial and send your first document for signature.
- Build an eSignature flow with the BoldSign skill in GitHub Copilot, our step-by-step guide.
- See how KBA checks a signer’s identity before they sign.
Frequently asked questions
Which artificial intelligence (AI) models does your team use for coding?
We use several models from more than one provider. The model choice mattered far less than the environment, specs and gates around the agent. That is the point of the title.
What does shipping faster mean for your engineering team?
It means more features and fixes reach production each month, with fewer waits between teams. Our knowledge-based authentication feature went from start to production in two weeks.
Does the AI coding agent touch production or production data?
No. Agent work ends in staging for now, and agents have no production access. A change reaches production only through our normal release process, after human review.
Do engineers still review code an AI agent writes?
Yes. A reviewer agent reads each diff with the gate results first. Then an engineer reviews the pull request, asks for changes if needed, and merges it.
What is a brownfield codebase?
A brownfield codebase is an existing system with years of business rules already built in. An agent needs a written map of those rules before it changes anything, so we had it write specs first.
What is a quality gate in AI coding?
A quality gate is an automatic check that must pass before work moves on. Ours build the code, run the declared tests, check coverage on changed lines and scan for secrets.
What happens when the coding agent gets stuck?
The agent stops after three different attempts on the same failing gate. It records why and hands the task to an engineer. We treat being blocked as a valid result.
Can I use an AI coding agent to build an eSignature integration?
Yes. Our guide to the BoldSign skill in GitHub Copilot shows how an agent writes eSignature code with our .NET software development kit (SDK).