Graph2Code

Use a Neo4J graph to generate a modernised codebase with full functional coverage.

Comment

GRAPH2CODE

Inspiration

We add in intern a proof of concept about old code migration from legacy sources to new code. To deal with the features of Back-End legacy code, that project generate functional graph representing all features divided by domain, use case and functional steps. The goal of this project is to generate a new implementation of those features in a new architecture, one user story at a time.

What it does

Graph2Code automates the journey from user story creation to code implementation and documentation updates. It ensures:

  • User stories are selected, written, and implemented efficiently.
  • Code changes are validated and linked back to the original user story.
  • Ensures code is compiling
  • Documentation remains up-to-date with every implementation.

How we built it

The workflow consists of four main stages:

  1. Selection of a User Story to Write
  2. Query stories from the database.

  3. Choose one to implement next.

  4. Creation of a User Story

  5. Use an AI agent to write a clear and actionable user story.

  6. Store the written story in the system.

  7. Implementation of a User Story

  8. AI agent generates the code based on the user story.

  9. Upload the implementation to the repository (e.g., S3 bucket).

  10. Validation and Storage

  11. Test the implementation.

  12. Validate functionality and link it to the user story.

  13. Update documentation and store both the story and implementation.

Challenges we ran into

  • Our company policy blocks Kiro, so we have to change our plans and go to AWS Cloud only.
  • Maintaining consistency between user stories and implemented code.
  • Automating validation without introducing false positives.
  • Integrating documentation updates seamlessly into the workflow.

Accomplishments that we're proud of

  • Built a fully automated pipeline from user story to validated implementation.
  • Reduced manual intervention, improving developer productivity.
  • The graph-oriented approach id the best one to deal with large codebase
  • Built our first AWS agentic pipeline :)

What we learned

  • The importance of clear user stories for successful automation.
  • How AI agents can accelerate development but require robust validation.
  • We discovered the complexity of the Bedrock ecosystem
  • We learned it's difficult to work in group on a same agentic pipeline

What's next for Graph2Code

  • Achieved real-time documentation updates linked to code changes.
  • Expand our workflow to Front-End projects
  • Add integration with CI/CD pipelines for continuous deployment.
  • Implement analytics dashboards to track progress and quality.
  • Explore multi-language support for global teams.

Built With

Share this project:

Updates