airhacks

• From screenshot / mockup / wireframe to maintainable UIs
• Building SPAs with web standards and LLMs
• Effective prompting strategies for web components
• Iterative refinement of LLM-generated components
• Consistent and repeatable design with design.md
• Extracting DESIGN.md from existing websites and screenshots
• Detecting drift between DESIGN.md and CSS design tokens
• W3C Design Tokens as CSS custom properties — no token tooling
• Why semantic markup and BCE reduce LLM hallucinations
• Taming large applications with feature-oriented structure
• Structuring feature modules with Boundary-Control-Entity
• SBCE for the frontend: capability specs as Web Component contracts
• Spec-driven Web Components with SBCE and vanilla BCE
• Declaring UI features as specs, converging to Web Components
• package-info.md as the business component contract
• Building high performance apps with Web Components and web standards
• Zero-dependency web apps with lit-html and Redux Toolkit
• No version upgrades, no breaking changes, no migrations
• Zero dependencies: no supply chain attacks
• Using Web Baseline to guide LLM technology decisions
• Multi-browser support with web standards and Baseline
• Capturing best practices with instructions, SKILL.md and AGENTS.md
• Implementing policies, guardrails and hooks
• Using specialised sub-agents for quality
• Import maps and ES modules without a build step
• Unidirectional data flow with Redux Toolkit
• Client-side routing with the Navigation API and URLPattern
• Custom events for component communication
• Automatic state persistence with localStorage
• Semantic HTML over div/span soup
• Native form validation instead of JavaScript re-implementation
• Less JavaScript with built-in HTML: dialog, popover, details
• CSS-only interactivity: accordions, modals, tabs without JS
• Accessibility with WCAG and focus management
• Modern CSS: nesting, logical properties, clamp() and oklch()
• Dark mode with prefers-color-scheme
• Responsive design with CSS Grid and container queries
• Testing web components with Playwright and MCPs
• Cross-browser E2E testing with Playwright
• Effective GitHub / LLM integrations
• Working with local LLMs
• Working with Claude Code, Kiro, GitHub Copilot and (...)
• Effective backend integration and full stack development
• From prompt to deployable web component SPA...
• (TBD)

Checkout for details: https://workshops.adam-bien.com/llm-assisted-webcomponents.htm

- 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