AI-Native Development: How to Stop LLMs From Producing Code Slop
- Date
- 2025-11-27
- Host
- Beyond Prompts
About this event
Large language models can help you ship faster, but they can also flood a codebase with brittle abstractions, shallow fixes, and confident nonsense. This in-person session is for developers and technical teams who want to use AI seriously without lowering the bar on code quality, architecture, or engineering judgment. What Is This? AI-native development is quickly becoming the default way many teams write software. But there is a big difference between using LLMs as productive collaborators and letting them generate code slop that slows everyone down later. This event focuses on that difference: how to work with AI tools in a way that improves output instead of quietly eroding standards. Expect a practical, grounded conversation around real engineering concerns. The goal is not to debate whether AI belongs in the development workflow. It is to explore how to use it well, where it breaks down, and what habits, constraints, and review practices help teams get the upside without creating long-term mess. Because this is an in-person gathering, the format is designed to support both learning and direct discussion. You will be in the room with other people who are actively thinking about autonomy, LLM workflows, and what good software development looks like when AI is part of the toolchain. What to Expect The session will center on the core problem in the title: how to stop LLMs from producing low-quality code that looks plausible on first pass but creates maintenance, reliability, and design problems over time. Rather than staying abstract, the discussion will likely stay close to developer realities such as code review, prompting discipline, system boundaries, and when human intervention matters most. You can expect a mix of structured content and community interaction. That may include: Framing the difference between useful AI assistance and code slop Discussing common failure patterns in LLM-generated code Exploring ways to keep architecture, readability, and testability intact Sharing practical habits for prompting, reviewing, and iterating on generated code Comparing experiences with autonomy, oversight, and engineering responsibility There is also a networking and community dimension built into the event. If you have been wanting to talk with other builders about the real day-to-day of AI-assisted development, this is a strong setting for it. The best conversations often happen when people move beyond hype and compare what is actually working in their own workflows. Why Attend If you are already using LLMs in development, this event will help you sharpen your standards. Many teams have reached the stage where the challenge is no longer access to AI tools, but knowing how to prevent subtle quality drift. This session is a chance to think more clearly about where AI speeds things up, where it introduces hidden costs, and how to build workflows that keep the gains while reducing the damage. You should come if you care about maintainability, code quality, and technical judgment. The value here is not just in hearing ideas, but in pressure-testing your own assumptions with others who are facing similar questions. How much autonomy is too much? What should always be reviewed manually? What signals tell you generated code is heading in the wrong direction? Those are the kinds of questions this event is built to surface. You will also leave with a stronger vocabulary for discussing AI-native development inside your team or community. That matters when you are trying to set expectations, establish review norms, or push for better engineering practices around rapidly adopted tools. Practical Details This is an in-person event taking place on Thursday, November 27 at 4:00 PM GMT. If you prefer discussions that are easier to engage with live, ask questions in the room, and continue informally afterward, the format should suit you well. The event is tagged with AI, LLM, autonomy, community, and networking, which gives a good sense of the audience and focus. You can expect people who are not just curious about AI, but actively interested in how these tools change the way software gets built and reviewed. Come ready for a thoughtful, technically informed conversation. Whether you are experimenting with AI-assisted coding for the first time or already deep into LLM-driven workflows, this is a chance to step back, compare notes, and get more deliberate about how AI fits into real engineering practice.
Who should attend
This is for people who want to use AI in development without accepting lower standards as the tradeoff. - You write, review, or maintain code and want clearer ways to spot when LLM output is helping versus quietly making the codebase worse. - You are experimenting with AI-assisted workflows and need practical guidance on prompting, reviewing, and setting boundaries around autonomy. - You lead engineering decisions, team practices, or technical standards and want better language for discussing quality, oversight, and risk. - You care about maintainability, readability, architecture, and testability, and you do not want speed gains today to become cleanup work later. - You enjoy talking shop with other developers, builders, and technically minded people who are thinking seriously about LLMs beyond the hype cycle. - You want an in-person setting where you can learn something useful, compare real experiences, and leave with ideas you can apply to your own workflow.