Next-Level Development: Harnessing AI with AIDE

If it’s worth doing by hand, it’s worth automating.

Just because not everyone is (yet) a world-class developer; that doesn’t mean we can’t step closer to that expert-level space. In this post, I will introduce AIDE (Artifical Intelligence Development Environment), a powerful workflow that merges AI-driven code generation with a sharp focus on documentation-driven development. With AIDE, I tap into the best of artificial intelligence (AI) while respecting the real human insight needed for domain-specific logic.

The result? An environment that streamlines repetitive coding, synchronises requirements, code, and tests, and elevates your engineering game.

Here is a practical example of an AIDE on GitHub developed using it’s own AIDE.

Introducing AIDE: Merging AI and Documentation-Driven Development

AIDE transforms development by combining:

  • Prompt Engineering with AsciiDoc: Clear, structured prompts guide AI to produce accurate, context-aware outputs.

  • Documentation-Driven Development: Documentation as the “single source of truth” ensures alignment across requirements, tests, and implementation.

  • Test-Driven Development: Unit tests validate outputs, forming a feedback loop between documentation and implementation.

At times, AIDE makes you feel more like a curator than a coder. Yet, this curation—refining AI-generated scaffolds and aligning them with domain-specific logic—delivers impressive results.

Why AIDE Empowers Developers

Confidence in Documentation

Documentation is the backbone of AIDE’s approach. With a cohesive workflow:

  • Single Source of Truth: AsciiDoc becomes a live blueprint, ensuring code, tests, and documentation stay aligned.

  • Real-Time Updates: Incremental updates highlight changes, prompting immediate documentation synchronisation.

  • Onboarding Simplified: New developers can onboard quickly, thanks to the always-current AsciiDoc artefacts.

  • Innovation-Focused Development: By delegating boilerplate tasks to AI, developers focus their energy on problem-solving and optimisation.

Escaping the Rewrite Loop

A common pitfall in software projects is rewriting patterns or boilerplate code repeatedly. AIDE circumvents this by allowing AI to scaffold foundational structures, leaving human developers to refine and innovate. Imagine a future where your mental bandwidth is reserved solely for solving real challenges.

The AIDE Workflow: A Seamless Feedback Loop

AIDE fosters a cyclical workflow that keeps requirements, tests, and code in lockstep:

  1. Document Requirements: Start with AsciiDoc. Clearly articulate requirements to guide both AI and developers.

  2. Generate Tests: Let AI draft test cases from the documentation; refine these for domain-specific nuances.

  3. Generate Code: AI produces initial implementations, scaffolded from documentation and tests.

  4. Review and Refine: Validate AI outputs, ensuring domain-specific logic and correctness.

flowchart LR
  A((Requirements
80% AI)) --> B((Unit Tests
80% AI))
  B --> C((Source Code
50% AI))
  C --> A

The Source Code is 50% AI because it requires more domain-specific knowledge and refinement. e.g. a unit test can be implemented in a few ways, but the source code needs to be correct and efficient.

AI ←→ Human Collaboration

The AI is adept at generating patterns and templates but lacks the intuition for domain-specific intricacies. AIDE leverages this by:

  • Allowing AI to propose code and test scaffolds.

  • Tasking Humans with oversight, refinement, and validation.

This symbiotic relationship ensures the resulting software is performant, accurate, and maintainable.

The Role of Documentation-Driven Development

In the AIDE paradigm, documentation drives development. This contrasts with the common approach of documenting code retroactively. Here’s why this matters:

  • Synchronisation: Documentation informs code and tests, reducing drift.

  • Clarity: Explicit documentation fosters a shared understanding across teams.

  • Scalability: Even in latency-critical applications, robust documentation ensures cross-team alignment without unnecessary overhead.

Consider a scenario where sub-millisecond latency is non-negotiable. Without precise documentation, minor misunderstandings can derail performance optimisations.

Practical Considerations

Learning Curve

Adopting AIDE requires a mindset shift:

  • Documentation First: Writing AsciiDoc before coding can feel counterintuitive but ensures clarity.

  • Guiding AI: Effective prompt engineering is key. Misguided prompts lead to irrelevant outputs.

AI’s Limitations

While AI excels at repetitive tasks, it falters in nuanced areas:

  • Complex Logic: AI struggles with advanced concurrency and domain-specific optimisations.

  • Token Constraints: Large files can overwhelm AI models. AIDE mitigates this by generating concise .ad summaries.

Diminishing Returns

Initially, AIDE accelerates development, generating requirements, tests, and code. However, as projects near completion, diminishing returns emerge:

  1. Early phases benefit from broad AI scaffolding.

  2. Subsequent phases focus on synchronisation and refinement.

  3. Final phases involve refactoring for maintainability, where AI’s utility diminishes.

The takeaway? Use AI for foundational tasks but expect manual effort for final polishing.

Key Takeaways

  1. Leverage AI for Boilerplate: Delegate repetitive tasks to AI, preserving your mental energy for strategic decisions.

  2. Synchronise Continuously: Use AsciiDoc as the source of truth to align requirements, tests, and code.

  3. Iterate Strategically: Small, frequent updates reduce complexity and ensure alignment.

About the author

As the CEO of Chronicle Software, Peter Lawrey leads the development of cutting-edge, low-latency solutions trusted by 8 out of the top 11 global investment banks. With decades of experience in the financial technology sector, he specialises in delivering ultra-efficient enabling technology which empowers businesses to handle massive volumes of data with unparalleled speed and reliability. Peter’s deep technical expertise and passion for sharing knowledge have established him as a thought leader and mentor in the Java and FinTech communities. Follow Peter on BlueSky or Mastodon.

Final Thoughts: Achieving "Next Level" Development

AIDE embodies a simple philosophy: automate where possible, refine where necessary. By combining AI’s efficiency with human insight, it transforms the development process. Whether you’re building a high-frequency trading system or a standard web application, AIDE reduces repetitive tasks, enhances clarity, and helps you focus on what truly matters: performance, scalability, and maintainability.

Most importantly, AIDE lets you level up your development practice, making it as efficient as it is effective.

Comments

Post a Comment

Popular posts from this blog

Java is Very Fast, If You Don’t Create Many Objects

Image
  You still have to watch how many objects you create. This article looks at a benchmark passing events over TCP/IP at 4 billion events per minute using the net.openhft.chronicle.wire.channel package in Chronicle Wire and why we still avoid object allocations..  One of the key optimisations is creating almost no garbage. Allocation is a very cheap operation and collection of very short-lived objects is also very cheap. Does this really make a difference? What difference does one small object per event (44 bytes) make to the performance in a throughput test where GC pauses are amortised? While allocation is as efficient as possible, it doesn’t avoid the memory pressure on the L1/L2 caches of your CPUs and when many cores are busy, they are contending for memory in the shared L3 cache.  Results Benchmark on a Ryzen 5950X with Ubuntu 22.10. JVM Vendor, Version No objects Throughput, Average Latency* One object per event Throughput, Average Latency* Azul Zulu 1.8.0_322 60.6 ...
Read more

System wide unique nanosecond timestamps

A Unique Identifier can be very useful for tracing. Those ids are even more useful when they contain a high-resolution timestamp.  Not only do they record the time of an event, but if unique can help trace events as they pass through the system. Such unique timestamps however can be expensive depending on how they are implemented.   This post explores a lightweight means of producing a unique, monotonically increasing system-wide nano-second resolution timestamp available in our open-source library. Uses for Unique Identifiers Unique identifiers can be useful to associate with a piece of information so that information can be referred to later unambiguously. This could be an event, a request, an order id, or a customer id. They can naturally be used as a primary key in a database or key/value store to retrieve that information later. One of the challenges of generating these identifiers is avoiding creating duplicates while not having an increasing cost.  You could ...
Read more

Comparing Approaches to Durability in Low Latency Messaging Queues

Image
  A significant feature of Chronicle Queue Enterprise is support for TCP replication across multiple servers to ensure the high availability of application infrastructure. I generally believe that replicating data to a secondary system is faster than syncing to disk, assuming the round trip network delay wasn’t high due to quality networks and co-located redundant servers. This is the first time I have benchmarked it with a realistic example. Little’s Law and Why Latency Matters In many cases, the assumption is that the latency won't be a problem as long as throughput is high enough. However, latency is often a key factor in why the throughput isn’t high enough. Little’s law states, “ the long-term average number  L  of customers in a  stationary  system is equal to the long-term average effective arrival rate  λ  multiplied by the average time  W  that a customer spends in the system”. In computer terminology, the level of concurrency or par...
Read more