DEV Community: CITYJS CONFERENCE

May the Source Be With You: Why Your AI Agent Is Only as Good as Its Knowledge

CITYJS CONFERENCE — Sat, 22 Aug 2026 19:48:18 +0000

Everyone seems to be building AI agents.

Give a model some instructions, connect a few tools, add a system prompt, and suddenly we have an "agent."

Except there's a problem.

A lot of them aren't particularly useful.

When an agent produces a poor answer, the immediate assumption is often that the model isn't capable enough. But sometimes the model isn't the problem at all.

The agent simply doesn't have the right knowledge to work with.

That's where things get interesting.

The Agent Is Only Part of the System

A simplified agent architecture might look something like this:

User
↓
Instructions
↓
AI Model
↓
Tools
↓
Answer

But for many real-world agents, something important is missing:

User
↓
Agent
↓
Relevant project knowledge
↓
Reasoning + tools
↓
Answer

An agent working on a real project may need to understand architecture decisions, terminology, conventions, constraints, processes, APIs, ownership, and dozens of other things that aren't part of the model's general knowledge.

Without that context, we're effectively asking the model to fill in the gaps.

And models are very good at filling in gaps—even when we'd prefer them not to.

Before Building an Agent, Ask Whether You Need One

There's another question that often gets skipped:

Does this problem actually need an agent?

Sometimes a simple rule is enough.

Sometimes a reusable skill or deterministic function is a better solution.

And sometimes an agent genuinely makes sense because the task requires interpreting context, combining knowledge, using tools, and deciding what to do next.

Thinking about that distinction before implementation can save a surprising amount of complexity.

A useful mental model is:

Predictable behaviour?
↓
Rule

Reusable capability?
↓
Skill

Context + decisions + tools?
↓
Agent

The boundaries aren't always this clean, but asking the question is useful.

Agents shouldn't be the default answer simply because agents are currently interesting.

What Should the Agent Actually Know?

Once we've decided that an agent makes sense, we reach a harder question:

What belongs in its knowledge base?

Imagine building an engineering assistant for a platform team.

We could give it everything:

/docs
/src
/wiki
/slack-export
/architecture
/runbooks
/meeting-notes
/random-document-from-2019

Technically, that's a lot of context.

Practically, it may be terrible context.

More information doesn't automatically mean better answers.

A useful knowledge base needs some structure. The agent needs to be able to find the right information at the right moment, and ideally understand which sources are authoritative.

That means knowledge architecture starts to matter.

Knowledge Architecture Is More Than Uploading Documents

It's tempting to think of an agent's knowledge base as a folder full of Markdown files.

But consider two documents:

architecture.md
architecture-final-v2-USE-THIS.md

Which one should the agent trust?

Now imagine 500 documents with overlapping information, outdated decisions, duplicated explanations, and inconsistent terminology.

Humans struggle with that.

An AI agent will struggle too—although it may sound considerably more confident while doing so.

A good knowledge architecture needs to answer questions such as:

What does the agent need to know?
Which information is authoritative?
How should knowledge be divided?
What terminology should be consistent?
Which information changes frequently?
Which relationships between concepts matter?
What shouldn't be included at all?

This is less about storing information and more about designing context.

Knowledge or Code?

There's another boundary that deserves attention.

Not everything the agent needs should live in its knowledge base.

Suppose we have this business rule:

Production deployments require two approvals.

Should that be documentation the agent reads?

Or should the deployment system enforce it?

If something must happen deterministically, relying on an LLM to remember a paragraph in a knowledge base is probably not the strongest architecture.

This gives us another useful distinction:

Knowledge
"What does this concept mean?"

Code
"What must the system always do?"

Agent
"What should I do given this context?"

Again, real systems are messier, but separating these responsibilities can make an agent much easier to reason about.

The Confidently Wrong Problem

One of the biggest risks with knowledge-based agents isn't that they say:

I don't know.

It's that they produce a perfectly plausible answer based on incomplete or outdated context.

For example:

Question
↓
Relevant knowledge missing
↓
Model fills the gap
↓
Plausible answer
↓
Wrong decision

Improving the prompt may help.

Changing the model may help.

But neither necessarily fixes the underlying problem.

Sometimes the real fix is:

Better source material
+
Better structure
+
Better retrieval
+
Clearer boundaries

That's why I think knowledge architecture deserves much more attention when we're designing agents.

Building the Knowledge Before the Agent

This is the idea I'll be exploring in a hands-on workshop called May the Source Be With You.

Rather than starting with:

Let's build an agent.

We'll start with:

What does this agent need to know?

We'll use Kipi, a knowledge-architecture tool, to plan and generate a structured knowledge base around a real project.

Only then will we put an agent on top of it.

The sequence matters:

Understand the problem
↓
Identify required knowledge
↓
Structure the knowledge
↓
Define agent boundaries
↓
Build the agent
↓
Test what it actually knows

The goal isn't simply to end up with another chatbot.

It's to understand the architecture underneath it.

The Interesting Part Isn't the Agent

Models will continue to improve. Agent frameworks will change. Today's fashionable abstraction will probably be replaced by another one.

But the underlying problem remains:

How do we give an AI system the right context to make useful decisions?

For teams building agents around proprietary systems, internal processes, products, or engineering platforms, that may become one of the most important parts of the architecture.

The model gets most of the attention.

The knowledge might be what determines whether the system is actually useful.

I'll be exploring this practically at CityJS Athens on 22 October 2026 at 09:00, in a hands-on workshop with Mey Beisaron, Senior Platform Engineer at NVIDIA.

Participants will build both sides of the system: a structured knowledge base using Kipi and a custom agent that operates on top of it.

Bring a laptop and, ideally, a project you already understand well.

And yes...

May the Source be with you. ⚔️

ai #agents #llm #knowledgearchitecture #javascript

AI-Powered Testing with Cypress: Smarter, Faster, More Resilient E2E Tests

CITYJS CONFERENCE — Sat, 22 Aug 2026 19:34:06 +0000

AI is changing the way we approach software development—and testing is no exception.

On 22 October, from 14:00 to 17:00, Agile Actors will host a session focused on AI-Powered Testing with Cypress, exploring how AI can help developers and QA engineers create, maintain, and improve end-to-end test suites with less manual effort.

If you've ever spent too much time fixing flaky tests, updating selectors after UI changes, or writing repetitive assertions, this session is for you.

Why AI-Powered Testing?

End-to-end testing is essential for ensuring that applications behave as expected from a user's perspective. But maintaining E2E tests can become expensive.

A small UI change can break multiple tests. Selectors change. Assertions need updating. Tests that worked yesterday suddenly become flaky.

AI introduces an interesting shift: instead of simply executing the instructions we've written, testing tools can increasingly assist us in creating those instructions and adapting them when the application changes.

During this session, we'll explore three capabilities that demonstrate this shift.

Generate Cypress Tests with Prompt Commands

Imagine describing the scenario you want to test using natural language:

Test that a user can log in, add a product to the cart, and complete checkout.

Instead of starting every test from scratch, Prompt Commands can help translate your intent into Cypress test code.

This creates an interesting workflow where developers and testers can focus first on what should be tested, while AI helps with some of the implementation.

We'll look at how Prompt Commands can accelerate test creation and where human review and testing expertise still matter.

Reduce Maintenance with Self-Healing Tests

One of the biggest challenges with automated UI testing is maintenance.

Consider a test that depends on a particular element or selector. The application evolves, the UI changes, and suddenly the test fails—even though the underlying functionality still works.

Self-Healing tests aim to reduce this problem.

With AI helping tests adapt to certain UI changes, teams can potentially reduce false failures and spend less time repairing tests after every frontend update.

The goal isn't simply to make failing tests pass. It's to create test suites that are more resilient to application changes while still detecting genuine regressions.

We'll explore how self-healing works, where it can help, and what teams should consider when introducing it into their testing strategy.

Create Tests Faster with Record Mode

Writing a good E2E test isn't only about performing actions.

We also need meaningful assertions.

That's where Record Mode becomes particularly interesting.

As you interact with your application, Cypress AI can suggest smart assertions based on what's happening on the screen.

Instead of manually translating every interaction into test code, you can work through the user journey while AI assists in creating the test.

This can make test creation faster while also helping identify useful assertions that might otherwise be overlooked.

AI as a Testing Assistant

The most interesting part of AI-powered testing isn't necessarily replacing the work of developers or QA engineers.

It's reducing the repetitive work around testing.

AI can help us:

Generate tests faster.
Reduce maintenance caused by UI changes.
Suggest useful assertions.
Improve the resilience of E2E test suites.
Spend more time thinking about what needs to be tested and why.

That last point is important.

AI can generate code, but deciding whether a test represents meaningful business behaviour still requires context, critical thinking, and testing expertise.

The value comes from combining AI assistance with good testing practices.

Who Should Attend?

Whether you're just getting started with Cypress or already running Cypress tests in production, this session will provide practical examples of how AI can fit into your testing workflow.

We'll look beyond the buzzwords and explore how capabilities such as Prompt Commands, Self-Healing tests, and Record Mode can change the day-to-day experience of creating and maintaining E2E tests.

Session Details

AI-Powered Testing with Cypress
Agile Actors
📅 22 October
🕑 14:00–17:00

If you're interested in Cypress, test automation, quality engineering, or the practical application of AI in software development, we'd love to see you there.

Let's explore what happens when Cypress meets AI. 🚀

AI-enhanced Angular apps with Genkit

CITYJS CONFERENCE — Sun, 12 Jul 2026 14:08:40 +0000

In this workshop, we embark on an exciting journey to create a booking application for a music studio. We will use Angular to craft an engaging UI, followed by the powerful backend API development with NestJS. Finally, we will enhance our application using AI by automating the booking process with the integration of Firebase Genkit into the API.

AI & Devs: Adopting To A New Reality

CITYJS CONFERENCE — Thu, 02 Jul 2026 10:47:43 +0000

Four years after ChatGPT changed how we think about software development, and 18 months after Claude Code pushed AI-assisted programming even further, one thing is clear: the role of developers is evolving faster than ever.

In this talk, I'll share my perspective as someone navigating this shift every day—not just adapting my own way of working, but helping developers build the skills and mindset they'll need to thrive in an AI-native world.

We'll explore questions like:
• What skills are becoming more valuable as AI gets better?
• How should developers think about learning and career growth?
• What does "being a great engineer" look like in the next few years?

Whether you're excited, skeptical, or somewhere in between, I'd love to have you join the conversation.

Taste: A Deep Dive

CITYJS CONFERENCE — Wed, 01 Jul 2026 14:54:20 +0000

What even is the role of JavaScript anymore? 🤔

For years, we've built experiences around familiar UI patterns: carousels, tabs, cards, modals, and forms. But as AI agents become part of how people interact with software, it's worth asking:

Are these design primitives still the future—or are we designing for a different kind of user?

In this talk, we'll explore:

How UX is evolving in the age of AI agents
What "agentic" experiences actually look like
Whether traditional interfaces still make sense
How developers can build products for a future where humans and AI collaborate

If you've been wondering how AI changes not just what we build, but how we build it, this session is for you.

Looking forward to the discussion—and to hearing your thoughts on where frontend development is headed.

Functional Programming, Monads & Category Theory for JavaScript Developers

CITYJS CONFERENCE — Mon, 22 Jun 2026 14:30:04 +0000

Many developers react to terms like monads and category theory the same way they react to regular expressions or recursion: with curiosity mixed with a bit of fear. This workshop aims to change that.

Starting from familiar JavaScript techniques, we'll gradually build a strong foundation in Functional Programming (FP), exploring concepts such as pure functions, closures, recursion, list processing, and lazy evaluation. From there, we'll uncover the practical value of monads and other category theory concepts, learning how they can help structure code, manage complexity, and solve real-world programming challenges more effectively.

This is a hands-on workshop designed for mid-to-senior JavaScript developers with at least 3 years of experience. Participants will code along throughout the session, so a working development environment (editor, browser, and git) is required.

Important: The workshop will be officially confirmed in August once the minimum number of 5 participants has been reached.

21-23 October - 2 Days training

🎟️ Tickets and registration: athens.cityjsconf.org

CityJS London 2026

CITYJS CONFERENCE — Wed, 01 Apr 2026 22:05:32 +0000

CityJS is back this year with another big events, Lets explore the new trends and the transition of technology to the AI Age. This year we celebrate the 30 years of JavaScript with a special guest, Douglas Crockford, the creator JSON will be with us for the closing keynote.

Make sure you attend for 3 days of Free Meetups, Workshops and a Full ay with over 40 speakers around the world. This is a rare opportunity you dont want to miss.

There is a variety of talks that cover many different topics, such as

AI + JavaScript (dominant theme)
Modern JavaScript runtime & ecosystem
Frontend architecture & frameworks
Performance & web platform optimization

This is a great opportunity for developers to see how their work will transition over to the AI Age.

Find out more on our website - https://london.cityjsconf.org