Revolutionizing AI-Assisted Programming: Frameworks, Practices, and Feedback Loops

AI coding assistants have transformed how developers write code, but they come with a familiar set of frustrations: jumping straight to implementation, making silent design decisions, forgetting constraints mid-conversation, and producing output that rarely meets rigorous engineering standards. Over the past few months, several contributions have emerged to address these pain points—from structured frameworks to new ways of thinking about developer feedback loops. This article explores the latest developments, including an open-source framework called Lattice, an expanded Q&A on Structured-Prompt-Driven Development (SPDD), and insights into the double feedback loop that makes AI-assisted development more adaptive and enjoyable.

Lattice: An Open-Source Framework for Structured AI Development

Rahul Garg recently published a series of blog posts on reducing friction in AI-assisted programming. Building on those ideas, he has now released Lattice, an open-source framework that operationalizes the patterns he described. Lattice tackles the core problem: standard AI coding assistants often lack engineering discipline. They generate code without reviewing against real-world standards, forget project-specific constraints, and don’t accumulate knowledge across sessions.

Revolutionizing AI-Assisted Programming: Frameworks, Practices, and Feedback Loops — Source: martinfowler.com

The Three Tiers of Composable Skills

Lattice introduces a composable skill system organized into three tiers:

Atoms – Basic, reusable units that encode specific engineering practices (e.g., Clean Architecture, Domain-Driven Design, secure coding patterns).
Molecules – Combinations of atoms that form more complex behaviors, such as a full code review workflow.
Refiners – Higher-order components that adjust the output of atoms and molecules based on context and feedback.

This layered approach embeds battle-tested engineering disciplines directly into the AI’s thought process. Instead of generic suggestions, Lattice ensures that every generated piece of code has passed through a filter of established best practices.

Persistent Context: The .lattice/ Folder

A key innovation is the .lattice/ folder, a living context layer that accumulates your project’s standards, decisions, and review insights. Unlike typical AI assistants that start fresh each conversation, Lattice learns from your history. After a few feature cycles, its atoms no longer apply generic rules—they apply your rules, informed by past decisions and peer reviews. This persistent memory makes the system smarter with use, gradually aligning with your team’s specific engineering culture.

Getting Started with Lattice

Lattice can be installed as a Claude Code plugin or downloaded for standalone use with any AI tool. Its modular design allows developers to customize which skills to include, making it adaptable to different project contexts and team preferences.

Addressing Common Questions About Structured-Prompt-Driven Development

A few weeks ago, colleagues Wei Zhang and Jessie Jie Xia published an article on Structured-Prompt-Driven Development (SPDD), which quickly generated enormous traffic and sparked numerous questions. To help readers apply the methodology effectively, they have now added an extensive Q&A section to the original article, answering a dozen of the most common queries.

SPDD Q&A Section Expands

The new Q&A covers topics such as:

How to structure prompts for maximum consistency
When to use SPDD versus traditional prompt engineering
How SPDD integrates with existing development workflows
Tips for scaling SPDD across large codebases

If you’ve been experimenting with SPDD or considering it, the updated article is now a more comprehensive resource. The double feedback loop concept discussed next can also complement SPDD’s structured approach.

The Double Feedback Loop: Molding Your Development Environment

Jessica Kerr, known online as Jessitron, recently shared a “merry tidbit” about building a tool to work with conversation logs from AI coding sessions. Her observation centers on a double feedback loop that many developers experience but rarely articulate.

“There are (at least) two feedback loops running here. One is the development loop, with Claude doing what I ask and then me checking whether that is indeed what I want. Then there’s a meta-level feedback loop, the ‘is this working?’ check when I feel resistance. Frustration, tedium, annoyance—these feelings are a signal to me that maybe this work could be easier.”

The first loop changes the product you are building. The second loop changes the thing you are using to build the product. In traditional software development, this meta-loop is often slow or ignored. But with AI making software change super fast, Kerr argues that modifying your tools to reduce friction pays off immediately.

Internal Reprogrammability Revived

This idea resonates with a concept once central to the Smalltalk and Lisp communities: internal reprogrammability—the ability to mold your development environment to exactly fit the problem at hand and your personal tastes. As IDEs became complex and polished, this freedom was largely lost, though the Unix command line always kept a flicker of it alive. Now, AI agents are rekindling that joy.

Kerr’s tool for processing conversation logs is a practical example: by analyzing feedback from AI interactions, developers can identify patterns of friction and then adjust their prompts, tools, or workflows accordingly. This self-modifying approach makes the development process not only more efficient but also more fulfilling.

“As developers using software to build software, we have the potential to mold our own work environment. With AI making software change superfast, changing our program to make debugging easier pays off immediately. Also, this is fun!”

Bringing It All Together

These three developments—Lattice’s structured framework, the expanded SPDD Q&A, and the revival of feedback-loop thinking—point to a maturing ecosystem for AI-assisted programming. Tools are no longer just chat interfaces that generate code; they are becoming platforms that embed engineering discipline, accumulate project knowledge, and empower developers to shape their own environments. As these patterns spread, the promise of truly intelligent, adaptable coding assistants comes closer to reality.

Tags: