If you read Part 1, you know how this started: I wanted to build a Star Wars LEGO database, my AI agent kept hallucinating schema that didn’t exist, and fixing that problem turned into my first open source contribution to neo4j-contrib/neo4j-skills.

That post told the story. This one shows the work.

Here’s why it’s worth following along: if you’ve ever asked an AI agent to help you build a database and ended up with queries that run but return nothing – because the labels are wrong, the relationship types are invented, the properties don’t match – this is the workflow that solves that. The agent reads a schema file before writing a single line of Cypher. You define it once from your own data. Everything after is validated against it.

I’m not an engineer. I did this entirely in plain English, with Claude Code running alongside the project in Zed. No Cypher knowledge required – I still don’t have any.

Now let’s walk through it.

What the contribution actually did – in plain English

The Neo4j cypher skill already knew how to write Cypher. What it didn’t have was a way to work when there was no database to learn from.

The skill needs a live connection to read the schema – what nodes exist, what relationships exist, what properties they have. Without that, it guesses. And as I showed in Part 1, it guesses wrong. It wrote :Minifigure when the label was :Minifig. It wrote :CONTAINS when the relationship was :HAS_MINIFIG. Plausible. Incorrect. No way to know the difference without a schema.

What PR #32 added was simple: read the schema from a file first. Before the database exists. Before you’ve written a single import script. Before you know anything about Cypher yourself.

That one change means a complete beginner can now:

• Describe their data in plain English and get a schema file written from their CSVs automatically
• Have every Cypher query validated against it – labels, relationships, properties, directions
• Import their data correctly the first time
• Query it in plain English without knowing the query language

You don’t need to know what a node is. You don’t need to know what a relationship type looks like. You don’t need an existing database to copy from. The skill holds all of that knowledge. You just have to show up with your data.

What you need

Everything in this walkthrough is free. I know because I checked before I started – I wasn’t building something that required a subscription or a credit card to follow along.

Zed – the code editor we’re using. Download at zed.dev. Available on macOS, Windows, and Linux.

Node.js / npm – required to run the npx skills add command. Download at nodejs.org (LTS version). Check with node --version in your terminal.

Python – required to run the import scripts. Download at python.org (version 3.8 or later). Check with python --version in your terminal.

Claude Code – the AI agent that does the heavy lifting. Install instructions at claude.ai/code. Requires a Claude Pro or API account.

Neo4j Aura Free – your free cloud graph database. Sign up at console.neo4j.io. No credit card required.

The Rebrickable CSVs – free to download at rebrickable.com/downloads.

That’s the whole list. No local database, no server, no infrastructure to manage.

Step 1: Install the skill

npx skills add neo4j-contrib/neo4j-skills/neo4j-cypher-skill

The CLI runs a security assessment before installing. When it completes, the skill is ready.

Step 2: Get the data

The dataset comes from Rebrickable – a community-maintained LEGO database with every official set, minifigure, part, and color as freely downloadable CSVs. No account required, updated daily.

That schema diagram is worth a moment. It shows the relational shape of the data: sets belong to themes, inventories link sets to their minifigs. This is exactly what we’re going to turn into a graph.

Step 3: Define the schema – before the database exists

And to be clear about what’s happening here: there is no Neo4j database running. No Aura instance, no local server, no connection string. Just CSV files and the skill.

That’s the gap the PR fills. Without a schema file, the cypher skill infers the schema – which is where hallucinated labels and wrong relationship types come from. With a schema file, every query is validated before it runs.

Use define_schema.py from the neo4j-cypher-skill to define a schema 
for a Star Wars LEGO graph database using the CSV files in this project. 
I want nodes for Theme, Set, and Minifig with relationships between them.

Claude Code reads the CSVs, builds the graph model, and asks permission to write lego-starwars-schema.json.

It writes the file and explains what it modelled and why – including the key insight that inventories and inventory_minifigs are join tables that become the INCLUDES_MINIFIG relationship with quantity as its property, not separate nodes.

No database. No connection string. No server running.

The schema file now exists. Every Cypher query Claude Code generates from this point forward is validated against it – not guessed.

Step 4: The Empire Strikes Back – the first roadblock

Claude Code also wrote import.cypher alongside the schema. When you prompt it to run that against a live instance, it stops before executing a single line.

LOAD CSV with file:/// paths works against a local Neo4j instance because the database can read your disk. AuraDB is cloud-hosted – it has no access to your local filesystem. Rather than fail, Claude Code reasoned through it and pivoted entirely:

This is the kind of thing that costs an hour of Stack Overflow searching if you hit it alone. Claude Code caught it, explained it, and fixed it without being asked.

Step 5: Set up a free Neo4j Aura instance

The onboarding builds a live graph of your answers as you fill in the form – you’re already thinking in nodes and relationships before you’ve written a single line of Cypher.

Within about 60 seconds your instance is running.

Step 6: Run the import

Claude Code runs import_aura.py and reports back.

Step 7: These aren’t the Star Wars themes you’re looking for

The Rebrickable CSVs contain every LEGO set ever made. We only want Star Wars.

Find all themes in the database that are related to Star Wars

It wrote and ran a graph traversal query using the HAS_PARENT relationship hierarchy. Initial result: 2 themes. I pushed back – I knew there were more than two.

Claude Code investigated with a diagnostic script and found the bug: the original query’s NOT EXISTS guard was too strict. There are actually 5 nodes named “Star Wars” in the data – the root theme plus sub-themes under Technic, Advent, and Mindstorms that were silently excluded.

I pushed back using nothing but domain knowledge. I didn’t write a query. I didn’t debug the code. I just knew there were more Star Wars themes and said so. The agent investigated, found its own mistake, and corrected it.

(I’d built this database once before and found 4 themes. Now there are 5 – Rebrickable updates daily. The data reflects the real world.)

Step 8: These are the droids you’re looking for

Since I don't know Cypher and I want to use the power of a Graph Database 
where relationships are first class citizens -- tell me which Star Wars set 
has the most minifigures?

What this actually gives you

From five CSVs to a queryable, visualizable Star Wars graph – no Cypher knowledge required, no database needed to define the schema, and every query validated against a file that existed before the first node was written.

The workflow in one line: define → import → query, with the schema as ground truth the whole way through.

I started this wanting to answer one question: which Star Wars set has the most minifigures? I ended up contributing to an open source skill that makes the whole workflow possible for anyone starting from scratch.

Install it with one command:

npx skills add neo4j-contrib/neo4j-skills/neo4j-cypher-skill

Drop a <db-name>-schema.json in your project root. Point Claude Code at it. The rest follows.

The 2008 Death Star has been sitting one-third built on my shelf since 2008. Maybe now that it’s fully assembled in a graph database, I’ll finally finish the real one.

The original guardrail project: github.com/andwaller/neo4j-dynamic-schema-guardrail The cypher skill it became: neo4j-contrib/neo4j-skills

Without an existing database, most tools assume you already know what you’re building. I didn’t. I had a pile of CSV files from Rebrickable and an idea.

That small frustration turned into something I didn’t expect: my first merged contribution to an open source repository.

A New Hope: The Force Was a Session

Last week our team ran a session with Zach Blumenfeld on his research into AIP (Agent Instruction Protocol) and how structured skills change the way AI agents perform. I’m not an engineer by trade, and working daily alongside a team like this makes me want to get my hands on things to better conceptualize new concepts.

So I did.

These Aren’t the Entities You’re Looking For

What I didn’t know at the time was that starting a graph project from CSV data has its own technical challenges. My plain AI agent had nothing to work from. I’d ask it to help me build a database and it would guess. Confidently, plausibly, and incorrectly.

Neo4j Agent Skills to the rescue – these encapsulate expert knowledge on graph data modeling, cypher generation and import.

I wanted to define the schema first, before the database existed. Tell the agent: here are the nodes, here are the relationships, here are the properties, now help me build it correctly.

The result was neo4j-dynamic-schema-guardrail: a SKILL.md file and a schema snapshot that any AI coding agent picks up automatically. No server, no library, no plugin, no live connection required. The agent reads the schema file before generating any Cypher, validates every entity against it, and halts with a structured report if something doesn’t exist.

I used it to load five Star Wars LEGO themes, 1,122 sets, and 1,528 minifigures into a Neo4j graph, built entirely from CSVs, with validated import scripts, before a single node was written. It worked better than I expected.

Go See Michael

When my VP saw what I’d accidentally built, he suggested I run it by Michael Hunger, VP of Product Innovation at Neo4j, to see if the project had value for the broader Neo4j community – specifically the neo4j-skills repository. I reached out with what I thought was a polite, low-pressure check-in.

Michael’s response was immediate and direct.

“Did you check the cypher skill we have in the skills repository? Would love to get contributions to that one.”

I’d thought I was at the end of an accidental side project. That one question changed the coordinates.

Before going back to Michael, I did the work of understanding where the guardrail fit. I installed the cypher skill and ran it the way I’d been working in a session with no live database connection to see what happened.

The cypher skill is built to validate against a live database: it reads the real schema before it writes Cypher. With no connection, it has no schema to read, so it does the reasonable thing and infers one. When I asked it to find all minifigures in a set, it generated:

MATCH (s:Set {set_num: $setNum})-[:CONTAINS]->(m:Minifigure)
RETURN m.fig_num AS figNumber, m.name AS name, m.num_parts AS parts

None of those entities exist in my database. The label is :Minifig, not :Minifigure; the relationship is :HAS_MINIFIG, not :CONTAINS; the property is id, not set_num. The query is plausible, and without a schema to check against there’s no way to know it’s wrong. That’s not the skill failing – it’s what happens to any tool when the schema isn’t available.

The guardrail reads the schema from a file, so it has something to check against even with no connection:

Schema Validation
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Node: Set          | ✅ FOUND
Node: Minifig      | ✅ FOUND
Rel: HAS_MINIFIG   | ✅ FOUND (Set -> Minifig)
Property: name     | ✅ STRING
Property: fig_num  | ✅ STRING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

MATCH (s:Set {id: $setId})-[:HAS_MINIFIG]->(m:Minifig)
RETURN m.name AS minifigName, m.fig_num AS figNum, m.num_parts AS numParts
ORDER BY m.name

Where each tool fits:

• graph-guard – real-time validation through a Bolt proxy server.
• cypher-query-validator – a TypeScript library you integrate into your code.
• neo4j-cypher-skill – validates against a live database connection.
• neo4j-dynamic-schema-guardrail – file-based, works without a connection, define-first workflow.

I put together a full evaluation brief, a live side-by-side comparison with real test outputs, and a complete session log, and sent all three back to Michael.

That’s when the real conversation started.

Padawan Github Project Training

Over the course of one day, Michael gave me feedback that changed how I thought about the project. Not the core mechanism, but everything around it.

“The LLM doesn’t read the README. It reads SKILL.md.”

“I don’t think you need the repository layout section.”

“Replace the screenshot with copyable text.”

“Does it attempt to map synonyms before halting?”

This question became a feature. If someone asks for Minifigure and the schema has Minifig, the original skill just halted. Michael asked whether it could suggest the close match first, and he was specific about the logic: if the match is unambiguous, resolve it silently and continue. Only halt if it’s genuinely ambiguous.

“Show the empty-database and import workflow clearly in ‘How It Works.’”

The most valuable thing I’d built – defining a schema from CSV before a database exists – wasn’t clearly described anywhere.

“Add support for the schema format in the neo4j-graphrag-python package.”

“Apply AGENTS.md to condense the skill.”

The principle is called “caveman compression”: remove articles, politeness, conjunctions, and explanatory padding, and keep technical content untouched.

Each time Michael gave feedback, I passed it directly to Claude and pushed the updates. At one point he wrote:

“you can just pass my feedback to Claude and let it fix it.”

Which made me laugh, because that’s exactly what I was doing.

The Contribution Itself

I’d never contributed to another open source project before in a technical way. Michael’s instruction was simple:

“Make a fork of the skills repo, have Claude clone it, tell it to apply and integrate the skill into a new branch, and open a pull request. You can just paste this instruction to Claude.”

So I did. It forked neo4j-contrib/neo4j-skills, created a branch, migrated the Python scripts and validation logic from the guardrail into the cypher skill, and opened PR #32.

Michael’s Final Edit, From the Plane

While in the air, Michael made one last change himself. He softened the strict “halt on failure” behavior into something more nuanced: only halt when the problem genuinely can’t be mitigated. Otherwise, propose a resolution, ask the user if needed, and proceed.

A guardrail that always stops is a blocker. One that tries to find a path forward first is a collaborator.

That shift was the last thing that went in before the PR merged.

What I Learned

The code changed less than I expected. The scripts mostly stayed intact. The validation logic was largely the same. What changed was clarity: about who reads what, what belongs where, what the tool is actually for, and how it should behave when something goes wrong.

The guardrail handles the what: are these entities real? The cypher skill handles the how: is this query well-formed? Neither replaces the other. That’s the complementary relationship.

I started out wanting to build a Star Wars LEGO database without hallucinated Cypher. I ended up with my first open source contribution, a much better understanding of how AI agent skills actually work, and a real lesson in the difference between something that works and something that’s ready to share.

The original guardrail lives at github.com/andwaller/neo4j-dynamic-schema-guardrail, and the neo4j-cypher-skill it is now is part of neo4j-contrib/neo4j-skills.

Originally published on the Neo4j Developer Blog, June 2026.

Presented at Devnexus / Atlanta Java Users Group, 2026. A conversation with Jeremy Adams-Casañas on Neo4j, graph-powered AI, and how the Atlanta tech community shaped a career path from technical recruiting to developer relations.

The Incident and Touch of Humanity

I work with an incredible engineering team at Neo4j. Our DevRel engineers are no exception, but they’re also very busy. I’ve been working on a community forums “game changer” that requires collaboration with one of my software developer colleagues. I thought I’d prepare by sharing a prototype, my “bit of vibe code”, to show what a possible solution could look like.

I was excited. For a moment, I thought I was building something special, or a spark for sharing a prototype worth collaborating on. I vibed hard. The UI front end looked pretty good for what we wanted to accomplish.

And then IT happened. My engineering colleague opened the doc.

Then came the look… Followed by a long, awkward silence that sucked the air out of the virtual room.

Finally, he said, trying to be polite but referring to some of the code I’d written:

“So, we need the ID to be able to identify the user… like, the code that you’ve got here… did you generate that with Claude or ChatGPT or something?”

“No, I wrote that by hand… with no engineering experience whatsoever.”

I tried to joke to lower the room temperature. Not funny. More silence.

Then he started walking through all the flawed backend security code I’d added, none of which had anything to do with what I actually wanted to discuss. I just wanted to show him my UI and get his thoughts on whether it had value.

He continued:

“Um, so I’m being honest. I’m finding this quite frustrating. It’s the kind of vibe-coded approach that’s only going to end up with more work for me in the long run.”

Some Context… Not Excuses

When the term vibe code became popularized by Andrej Karpathy earlier this year, it clicked for me. Maybe I could start finally bringing some of my ideas to life. Things I’d normally need a software developer to do.

10 PRINT "Hello!"
20 GOTO 10

That’s about as far as I got with my coding career.

What I didn’t realize while preparing for this call was that my attempt to help actually detracted from the goal and could have unintentionally built a wall between myself and the engineering team. I never thought I’d built a secure application, but noble intentions aside, I messed up. Big time.

Reflection… Did I Save Time… NO!

I’ve spent my entire career admiring, advocating for, and promoting the skill set of developers. So how could I have shown such a lack of respect for the art and craftsmanship that goes into software engineering, even unintentionally?

• Showing a fine artist a finger painting and calling it a collaboration.
• Handing a surgeon a multitool and saying, “This might help.”
• Submitting a bridge concept drawn in crayon to a structural review.
• Walking into a jazz quartet with a drum machine set to “demo mode.”

The good news: I was in a safe space with a trusted colleague. A few days later, I called him back to sincerely apologize. He apologized too, saying maybe he’d been too blunt, but I disagreed. It was a much-needed lesson for me, and maybe one for anyone reading this.

AI may be known for hallucinations, but let’s not hallucinate ourselves into believing we can plug something into an LLM and suddenly call ourselves experts.

Engineers are connoisseurs. They don’t just build; they curate. Each line of code carries intention, security, and beauty. They see risk where I see rhythm. I painted with broad strokes, skipping the fine details. And the real engineer? They weren’t dismissing me. They were protecting the canvas.

The Takeaway from the Watershed

So yes, spoiler alert: your vibe code isn’t impressing engineers. But that’s okay. Sometimes, the most valuable feedback you’ll ever get isn’t praise; it’s a sigh, a silence, and a moment of truth that helps you grow from vibing to building.

My personal takeaway: the word vibe feels so casual. Coding is anything but. If you’re not a technologist (like me), you’re a vibe coder. But when a software engineer uses a GenAI tool, that’s AI paired programming.

Originally published on Medium and IVibeCode.ai, October 2025.

My answer? “Only if it represents what you’re truly capable of.”

Let me explain.

Skills Speak for Themselves

Hiring managers don’t just want to know what you’ve read; they want to know what you’ve built. In countless interviews and hiring discussions, what stood out wasn’t just the list of technologies on a resume but how a candidate could talk about their work, explain trade-offs, and show real-world problem-solving.

It wasn’t about buzzwords or just saying “I’m certified!” It was about capability.

When developers take the time to level up on their own terms, whether through side projects, community involvement, or certifications that actually require hands-on work, they signal something bigger: initiative, curiosity, and a deep engagement with their craft.

Real skills. Real curiosity. Real passion for building.

If that resonates with you, you’re exactly the kind of developer who stands to benefit from earning a Neo4j certification.

Why Neo4j Certification Matters

One thing I value most about working at Neo4j is our genuine commitment to the developer community. We offer free Neo4j courses and certifications on GraphAcademy because we believe high-quality graph database education should be accessible to everyone. The certification may be accessible at no cost, but it must still be earned.

So why does it matter?

It proves you can do the work.

GraphAcademy isn’t set up for passive learning. You’re not just clicking through slides or memorizing concepts for a quiz. You’re writing Cypher queries, modeling real data with nodes, relationships, and properties that mirror the complexity of real-world systems. The path toward becoming a Neo4j Certified Professional is hands-on by design. You’re asked to demonstrate understanding, not just recall.

It gives you an edge in AI and emerging tech.

Knowledge graphs are becoming a foundational component of AI and agentic systems, especially in retrieval-augmented generation (RAG), recommendations, and context-aware applications. As part of the emerging Model Context Protocol (MCP), graphs play a critical role in enabling LLMs to access structured, dynamic knowledge. Certification prepares you to show how you can build the data layer on which modern AI depends.

It connects you to a real community.

Learning solo can be rough. That’s why the Neo4j dev community – including Discord and discussion forums – are such a game-changer. They’re packed with thousands of engineers, data folks, and graph experts who are building real projects, swapping ideas, and debugging together. Whether you’re stuck on a query or exploring a new use case, there’s always someone who’s been there and is ready to help.

It unlocks what’s next.

Want to go deeper? Tracks like Neo4j Graph Data Science and Neo4j Certified Professional both build on this foundation. The certification is your launch point for more advanced graph learning. Pair the cert with a side project, and you have proof of work. Something real you can show, explain, and use to spark deeper conversations.

Summary

Neo4j certification isn’t just a free t-shirt, an online certificate, and a community badge. It’s a signal to yourself, your peers, and future collaborators that you’re serious about building what’s next. Whether exploring the future of AI, diving into data modeling, or adding graph capabilities to your developer toolkit, this certification helps you stand out with practical, proven, and in-demand skills.

Ready to Build What’s Next?

If you’re the type of developer who learns by doing, this is your moment. Take the challenge, earn the certification, and show the world what you can build. It’s a declaration that you have the ability to apply what you know and graph data to solve real-world problems, especially in an AI-driven future.

• Start the Neo4j Certified Professional certification
• Explore all GraphAcademy learning tracks
• Join the Neo4j Developer Community and our Discord

Originally published on the Neo4j Developer Blog, June 2025.

Presented at the Atlanta Java Users Group (AJUG), July 2023. Co-presented with Joseph Krull.

Presented at Seattle DevOps Meetup, June 23, 2021.

Presented at San Diego Python virtual meetup, June 25, 2020.

Which is a better JavaScript or Java? Well, when the chips were down, and an anticipated conference, ngAtlanta, was canceled for both paid attendees and sponsors, the answer to that question really did not matter. What did matter was the actions the Atlanta Java Users Group (AJUG) took to ensure the ngAtlanta community were taken care of in their time of need.

If you think putting on a successful conference is easy, think again. It takes a lot of experience and know-how, and even then, a wrong decision can be costly enough to tank the whole event. The leaders of AJUG, Vincent Meyers and Pratik Patel, have learned through many years of experience (and bumps and bruises along the way) how a disappointment like this can impact the morale and confidence in the tech community.

Perhaps this is why when I commended Vincent on their heroic actions he humbly and simply stated, “we could do it, so we did.”

Every year, AJUG puts on Devnexus, the largest independent software development conference in the country. This year, with the Georgia World Conference Center (GWCC) as their venue, 2400+ attendees as well as scores of sponsors, gathered in Atlanta. With only 2 weeks to spare, Vincent and Pratik heard the disappointing news: ngAtlanta was canceled, and those attendees and sponsors who had paid were “out of luck” as no refunds were being offered.

The AJUG and Devnexus team swiftly jumped into action. With the help of Angel Banks, an Atlanta tech community hero who is a director of the Atlanta Women Who Code chapter and organizer of Refactr.Tech – an Atlanta tech conference with a focus on diversity and inclusion – they contacted paid attendees, sponsors and speakers scheduled to participate in ngAtlanta. They used their venue at the GWCC to put on a conference-within-a-conference for the ngAtlanta community which included meeting space, audio/video equipment, parking, food, parties, raffles, and swag. Oh yeah, they also made all Devnexus conference sessions, and an extra conference day available to those who had already paid to go to ngAtlanta.

This year, I was honored to be part of a technical conference that not only exceeded the expectations of those who attended but also took swift action to unify the community.

Originally published on Medium, February 2020.

Presented in 2020.