airhacks

- LinkedIn: https://www.linkedin.com/in/adam-bien
- github: https://github.com/AdamBien
- online workshops: https://airhacks.live
- Adam Bien's official website: https://adambien.blog/
- YouTube channel: https://www.youtube.com/user/bienadam
- Adam Bien @BlueSky: https://bsky.app/profile/adambien.blog
- Occasional airhacks news: https://airhacks.news

‼️Need an invoice? Register via EventBrite 👉 https://airhacks-university.eventbrite.de

One day of coding, debating and shipping Java with Adam Bien (linkedin.com/in/adam-bien). Five years online. Now back at MUC, in person.
A small cohort, one full day, and a repository you keep.
This is an advanced, hands-on workshop on architect-grade, LLM-assisted Java development — using LLMs and agents to ship maintainable, well-tested Java without slipping into vibe coding.

Learn how to (checkout full agenda: https://airhacks.university):
What you'll learn

Agents, subagents, context, LLMs, MCP, tools, skills, agents and agent memory (...) basics / introduction
Developer / LLM synergy: who does what
Effective communication with domain experts and product owners
Bridging domain experts and Java implementation
Requirements clarification with stakeholders
From specs to working Java code
Spec-driven development for Java and Web Platform projects
LLM-native architectures, planning and design
Scaling LLM-driven development to large systems
The LLM impact on architectural principles:

• Rethinking DRY and DIE in the LLM era
• YAGNI and KISS in LLM-generated code
• Separation of Concerns with LLMs
• Maximal Cohesion, Minimal Coupling: why cohesion beats coupling in the context window
• Information hiding as a context-window strategy
• Reusability and modularization in LLM-first projects
• Do hexagonal architectures survive LLMs?
• Do we still need microservices?
• Continuous improvement workflows for Java teams

Continuous review of generated Java code
Continuous compliance with architectural rules
Unit-, Integration- and System Testing with LLMs
Capturing architectural rules with Skills
Creating efficient AGENTS.md
Hyperproductivity without sacrificing maintainability
Refactoring with continuous test feedback
Using specialised sub-agents to improve code quality
Capturing best practices as executable hooks
MCP integrations for Java workflows
Reusing Skills and sub-agents for recurring tasks
Understanding token economics and reducing inference costs
Unorthodox LLM-first approaches for security, maintainability and productivity

• ...(TBD)

Full agenda: https://airhacks.university

Join Adam Bien (linkedin.com/in/adam-bien) for a hands-on workshop for a hands-on workshop on turning ideas into production-ready Java code with LLMs and agents. Learn how to go from ideas to structured specs, and specs to deployable, consistently structured Java code grounded in best practices. Accelerated and incrementally refined at every step by LLMs and agents.

• Learn how to (checkout full agenda: https://airhacks.live):

• Building zero-dependency business agents with zsmith

• Single-file agent scripts with no build step

• The agentic loop explained from the source

• Composing tools, profiles, and custom schemas

• Tool permissions and safe execution control

• Skills as portable prompt snippets

• Episodic memory persisted across runs

• Subagents and parallel delegation

• Serving local agents over HTTP

• Local on-device inference

• Provider swapping without code changes

• Built-in agent observability

• Building agents with MicroProfile (Quarkus)

• The tool-calling loop hidden by AI Services

• Composing tools as annotated CDI beans

• Persistent chat memory across sessions

• Streaming responses to the client

• Structured outputs mapped to records

• Guardrails for input and output

• Local inference with Ollama

• Model provider swapping via configuration

• Observability with OpenTelemetry and Micrometer

• Exposing agents over the Agent2Agent (A2A) protocol

• Testing LangChain4j agents

• Serverless agents on AWS Bedrock AgentCore Runtime

• The agent loop run by AgentCore Runtime

• Exposing Lambda tools via AgentCore Gateway

• Short-term and long-term AgentCore Memory

• Tool access secured with Cognito and JWT

• MCP-based tool access over the gateway

• Managed cloud inference with Bedrock models

• Foundation model swapping via configuration

• Containerizing zsmith or Quarkus agents with CDK

• Cloud observability with CloudWatch tracing

• From local script to serverless deployment

• (TBD)

Full agenda: https://workshops.adam-bien.com/building-local-and-serverless-llm-agents.htm

Join Adam Bien (linkedin.com/in/adam-bien) for a hands-on workshop for a hands-on workshop on turning ideas into production-ready Java code with LLMs and agents. Learn how to go from ideas to structured specs, and specs to deployable, consistently structured Java code grounded in best practices. Accelerated and incrementally refined at every step by LLMs and agents.

Learn how to turn legacy Java into maintainable, standards-based, zero-dependency code. Learn how to extract specs and tests from existing applications, then migrate incrementally to modern JDKs, BCE, and MicroProfile, with LLMs and agents doing the mechanical work, and tests as verification loops. (checkout full agenda: https://workshops.adam-bien.com/llm-assisted-legacy-system-migration-to-modern-java.htm):

• Reverse-engineering intent from undocumented legacy code
• Extracting the ubiquitous language from legacy code
• Ubiquitous language as migration compass: naming BCs, boundaries and entities
• Capturing the structure of existing databases with custom MCPs: exposing schemas to LLMs for context-aware migration
• Extracting characterization tests from existing applications: verification loops for the migration
• Spec-driven BCE (say "Space") migrations with SBCE
• LLM-assisted creation of OpenRewrite rules: generating recipes for repeatable, large-scale migrations
• Defining custom skills to capture transformation rules: reusable, shareable migration knowledge for developers and agents
• Automating migrations with purpose-built agents
• Pruning dependencies and custom frameworks for security, productivity and maintainability
• Migrating custom-grown frameworks to Java SE and LLM-friendly standards with stable APIs and normative specifications (e.g. MicroProfile)
• Replacing external dependencies with standards: more security, less maintenance
• Traceability: mapping legacy components to their migrated counterparts for auditable, verifiable migrations
• (TBD)

Full agenda: https://workshops.adam-bien.com/llm-assisted-legacy-system-migration-to-modern-java.htm