AfterCode Intelligent Automation

A post-code automation framework that streamlines CICD lifecycle via GitLab Duo agents and event-driven workflows.

Comment

Inspiration

Writing code is only one part of building reliable software. After a developer finishes a change, it still needs to be reviewed, tested, checked for security risks, and prepared for delivery. These activities often involve a wide array of tools, repetitive checks, and manual investigation when something fails.

I wanted to explore a different approach: what if the work that happens after code is written, could be coordinated by AI agents and event-driven automation?

Hours of manual labour spent debugging errors can be removed. Streamlining the entire process, optimising the framework and improving efficiency formed the central part of the project.

What it does

brings together GitLab Duo flow automation and a CI/CD pipeline to support the post-code software lifecycle.

Its key capabilities include:

  • Merge request readiness: An AI-powered workflow analyses merge requests to help developers assess whether changes are ready for review and delivery.
  • Failure rehearsal: A configured workflow explores potential failure scenarios and helps identify risks before delivery.
  • Product evolution insights: A configured workflow provides AI-assisted analysis intended to support future improvements to the project.
  • CI/CD verification: Automated pipeline jobs run application tests and verification checks.
  • Security and dependency checks: The pipeline includes secret detection, static application security testing, and frontend dependency auditing.
  • Packaging: Backend and frontend packaging jobs help prepare project components for delivery.

The project uses event-triggered GitLab Duo flows to connect AI-assisted analysis with development events. I successfully tested three configured flows using a merge request, alongside a successful CI/CD pipeline.

The goal is to move beyond isolated scripts toward a coordinated workflow that helps developers understand risks, validate changes, and make better delivery decisions.

How we built it

I built a Task Manager application using React and FastAPI with SQLite and SQLModel supporting data persistence.

I integrated the project with GitLab CI/CD and configured pipeline jobs for backend and frontend testing, dependency auditing, security scanning, and packaging.

I then configured GitLab Duo Agent Platform flows around key development activities, including merge request readiness, failure rehearsal, and product evolution. Event triggers connect these workflows to merge request activity, allowing the configured automation to respond to development events.

I also explored supporting MCP tooling to extend the automation with project-specific capabilities.

Challenges we ran into

One of the biggest challenges was understanding how GitLab CI/CD, GitLab Duo flows, event triggers, and MCP tooling fit together.

Configuring an agent is only one part of the problem. The workflow must also have the correct trigger, permissions, and execution environment before it can respond to a real development event.

I also needed to distinguish between a workflow being configured and a workflow actually executing. I addressed this by creating a dedicated test branch and merge request, then checking the resulting flow executions.

Accomplishments that we're proud of

  • Built a working React and FastAPI application integrated with GitLab.
  • Established a successful CI/CD pipeline covering testing, dependency auditing, security scanning, and packaging.
  • Configured GitLab Duo flows for merge request readiness, failure rehearsal, and product evolution.
  • Successfully triggered and tested all three configured flows using a merge request.
  • Connected automated verification with AI-assisted workflows to demonstrate how different parts of the post-code lifecycle can work together.
  • Created a practical foundation for exploring more autonomous software delivery while retaining human review and oversight.

What we learned

I learned that effective AI automation requires more than a capable model. Reliable triggers, clear workflow boundaries, appropriate permissions, deterministic verification steps, and observable execution results are equally important.

I also learned that AI-assisted analysis and conventional CI/CD checks complement each other. AI can help interpret changes and identify potential issues, while automated tests and security scanners provide repeatable checks.

What's next for AfterCode Intelligent Automation

Planned improvements include:

  • Repository-aware analysis: Adapt checks and recommendations to each repository's language, framework, dependency files, and project structure.
  • Expanded security analysis: Correlate dependency, secret-detection, and static-analysis findings to prioritise actionable risks.
  • Delivery-readiness scoring: Combine test outcomes, security findings, and merge request analysis into a clear readiness summary.
  • Sustainability-aware execution: Explore ways to reduce unnecessary pipeline runs and resource consumption, with measured evidence of any resulting improvements.

Built With

Share this project:

Updates

Submission history