Bondi AI Collective: AI-Assisted Coding Workflows

A fabulous Bondi AI Collective event today with Chris Adams and Steffen Wilhelm sharing details of their AI coding workflows, and a number of other experienced AI-augmented developers in the group also sharing great insights from their experience.

A summary of what was discussed:

🧠 Overall Workflow: AI-Augmented Software Development

1. Three Types of Developers in the Room

• Group A: Trained engineers like Chris — backend/full stack, strong foundations.

• Group B: Self-taught “vibe coders” like Steffen — not classically trained but building real systems with AI assistance.

• Group C: Non-coders — curious observers, not yet coding but interested in how AI reshapes development.

2. Core Development Workflow (as practiced by Chris and others)

Step 1: Ideation and Scoping

• Done in natural language using tools like Claude, ChatGPT, or Gemini.

• Often starts with dictation, idea dump, or feature descriptions.

• Generate specifications, task breakdowns, or epics/features in markdown (e.g., feature_3.3.md).

Step 2: Coding Agent Initiation

• Use tools like Manus, Claude Code, GitHub Copilot (Agent Mode), or Cursor.

• Tools read codebase, generate changes across files, and may test/debug their work using browser emulators.

Step 3: Plan Mode and Execution

• Some tools (e.g., Claude Code) support Plan Mode, where AI presents a plan for approval before execution.

• Auto-approve mode available for experienced users who trust the model for larger chunks of work.

Step 4: Review and Accept/Reject Changes

• Interfaces allow you to review suggested code changes across multiple files.

• Early tools required line-by-line acceptance (e.g., Cursor), but newer tools support chunk-level approval and agentic flows.

Step 5: Local Testing and Debugging

• Download the generated codebase to local machine.

• Use GitHub and VS Code to run, test, and commit.

• Tools like Playwright MCP help capture browser-side errors for debugging.

Step 6: Iteration and Refactoring

• Use AI to refactor for maintainability or architecture (e.g., layering with Domain-Driven Design).

• Incorporate constraints, style rules, or refactoring prompts.

• Example: Restructuring messy frontend/backend logic into clean architecture layers.

🔍 Insights and Lessons Learned

1. AI as a Development Partner

• Treat LLMs like junior engineers: if you can manage and instruct them well, you get high leverage.

• AI tools can now work across multiple files, search the entire codebase, and understand project architecture.

2. The Rise of Modal Interfaces

• AI dev tools are increasingly split between:

  • Ask Mode: conversational, exploratory.

  • Agent/Code Mode: operational, file-editing and executing code.

• This paradigm will likely expand to other professions and workflows.

3. The Importance of Language and Jargon

• Knowing the right technical jargon (e.g., DDD, application service layer, etc.) activates latent model capabilities.

• Effective prompting = bridging natural language with technical context.

4. Documentation and Specs Still Matter

• Specs (even model-written) keep AI and humans aligned.

• Embedding feature descriptions, status tracking, and testing requirements helps in long-term manageability and context-switching.

5. The Ceiling of Complexity

• Key challenge: determining the right unit of work for the model.

  • Too simple = wasted overhead.

  • Too complex = hallucinated or incoherent outputs.

• Complexity ceiling also manifests in trusting multi-file changes when unsure what’s happening under the hood.

6. Tool-Specific Insights

• Manus is strong for Python-heavy tasks and browser testing.

• Cursor is fading in usefulness due to clunky UI for large-scale edits.

• Claude Code with Plan Mode allows for safer oversight.

• GitHub Copilot Agent Mode is a powerful upgrade, especially for structured workflows.

7. The Future Is Graph-Based

• For knowledge and data-intensive apps, graph technology is critical.

• Supports richer, bidirectional relationships ideal for GenAI and RAG systems.

8. Learning Curve and Empowerment

• Steepest learning curve = highest payoff.

• AI now acts as a teacher, debugger, and collaborator.

• The path from B to A is open and accelerating.

✨ Takeaways for the B’s and C’s

• You don’t need to be a traditional dev to build powerful software today.

• AI lowers the barrier to entry, but climbing the curve still takes time and intentional effort.

• Having a real project is the best way to stay motivated and structure your learning.

• Don’t take the first AI answer. Loop a few times, challenge it, and refine.

• Use a modular workflow: scoped features, markdown specs, clear tracking, and staged commits.