Loading video player...
AI coding is constantly evolving. Whether you use Claude code or cursor, it doesn't matter.
People are realizing that simply giving a large prompt to your AI coder is not
enough anymore. This realization led to the introduction of context engineering a while back. Now,
I had problems with this approach as well. Context engineering is basically the art of
filling the context window of the model with only the stuff that it needs to
know for a specific task. Sounds good in theory, right? But here's the issue. You
never follow a set path when coding. You encounter errors, you might need to implement
something new or you discover you need additional context midway through. When that happens, you're
stuck. You need to constantly update your context. What you really need is your own
knowledge base and not just any knowledge base but one through which the AI agent
can get the accurate data it wants as fast as possible. This is where this
new agent system, Archon, comes in. Let me give you a clear overview of Archon
and then explain how it solves one of the biggest problems in AI coding. Let's
start with the project I have two projects here, a test project and a task
class project. Each project contains two essential tabs, docs and tasks. This is your complete
context management system. Your documentation lives here, giving your AI agent full knowledge of your
project. When I open this, you'll notice they've added templates. This means when your AI
agent connects, whether it's Claude or Cursor, it doesn't create random documentation. It follows these
templates, like architecture documentation or feature PRDs, keeping everything properly organized. The
tasks tab works beautifully with your documentation. Based on your project scope, meaning what you
want to build, the backlog automatically populates with relevant tasks. The AI agent manages
tasks independently and maintains task memory. It never loses context and always knows which
tasks need completion. You can create unlimited projects and manage them efficiently. In my task
class project, for instance, one task sits in the backlog while 13 are actively in
progress. Next is the MCP server, which connects Archon to your AI agents. Setup is
remarkably simple. They have setup commands for all agents, like Claude Code, whose command is
really hard to search up. This is especially valuable for users uncomfortable with code editors
or terminals. Now here's the feature that makes Archon exceptional, the knowledge base. The knowledge
base accepts any documentation you need. You can add links to any tools documentation. For
example, I imported the entire SwiftUI documentation from Apple's developer site. That's
505 pages containing over 126,000 words. In the add knowledge base
section, you'll find categories of knowledge. You can add URLs or hosted documentation sites. The
application
What
makes this different from other tools? Archon implements a complete RAG system. When you install
it, you're setting up a proper database for RAG instead of simple text search. The
system stores data and applies semantic search. The result is fast, accurate, and personalized retrieval.
Here's a practical example. In my test project's docs section, I I can add project-specific
sources. Say I'm building a Swift app and Liquid Glass UI just released. LLMs don't
know about it yet. The solution is feeding ARK on the Swift UI documentation. I
added the docs to the knowledge base, set the crawl depth to 2, which is
optimal, and let the crawler process everything. The crawler works programmatically. It follows every link
on the site, navigates through menus, enters each page, and extracts all information systematically. This
is a comprehensive system combining context engineering, RAG, web script,
That's the
beauty of this community. Now, a quick break to
tell you about today's sponsor, Logs.so. Ever launch a feature and have no clue if
anyone touched it? Or find out about a payment failure only when a customer tweets
at you? Logs.so shows every sign-up, click, payment, and error in one live feed. No
dashboards, no dev console, just a simple timeline anyone on the team can read. You
don't have to wire up fancy tools or write code. Paste one line into your
site or drop the snippet into whatever builder you're using and watch events roll in.
The first 1,000 events every month month are free forever. That's enough to track a
side project or prove value before you even pay a cent. Ready to see what
really happens in your product? Hit the link below and start tracking with logs.so. This
is the GitHub repository of Archon and the first thing you're going to do is
come here and copy the link. Then you'll go back into your terminal. You're going
to clone the GitHub repository and add it inside your chosen directory. You can see
that for me it already exists and I already have it up and running successfully.
When I ran it you can see it completed successfully. After the GitHub repository is
installed, you're going to run this specific command that's shown right here in the GitHub
repository. This command will create your .env file, where you need to put some important
variables that I'll show you in just a moment. Now, since Archon is a proper
knowledge hub, it needs a proper database to perform RAG and all the AI searching
capabilities that it provides. For this, the author has chosen to use Supabase as the
main database, and setting it up is really simple. First, make sure you have a
project created in Superbase. As you can see, I created a project called Archon. The
great thing is, you don't need to pay for this. The free version of Superbase
is absolutely enough for what we need. Next, you need to create your database tables
inside Superbase. But don't worry about having to do that manually. They've provided an automatically
configured setup that makes this incredibly easy. All you have to do is open the
current repository inside cursor so you can easily access all the files. Just use this
command. It'll open the Archon repository directly inside cursor. Once you're inside cursor, navigate to
the migration folder. There you'll see a complete setup.sql file with everything configured. Simply
copy the whole thing and go back into Superbase. In the Superbase sidebar, you'll find
the SQL editor. You can see that I've already pasted mine, but basically you paste
the SQL code there and run it. Once it finishes executing, you'll see the message,
success and no ruse returned. That confirmation means the database has been set up correctly.
Now once you're done with that setup, you need to grab two important credentials. Head
into the settings section of Superbase and first go to the data API section. Here,
you'll get your project URL. Copy that. Then navigate to API keys. Reveal the service
role API key and copy that as well. Go back to your .env file. Remember
the .env is a copy of the .env.example file which you created earlier using the
cp command. Here you'll paste your Superbase URL that you just copied and then paste
your service role key in the appropriate field. Once you've done that, you'll run the
Docker Compose Up command. The first time you run this command, it will take some
time as it needs to fetch and build all the Docker containers. For this to
work, you do need to have Docker running. So make sure Docker is turned on
and running in the background on your system, whether you're on Windows or Mac, before
executing this command. Docker will go ahead and start all the containers and you'll see
a progress bar showing the setup progress. Once it finishes, you'll see that four containers
have been started. Archon Agents, Archon Server, Archon MCP and the front end. Finally, if
you go to the Archon UI, which is now running, you'll find it at localhost
3737. Just enter that address in your browser and it will automatically take you through
the first step, the onboarding step that gets everything configured for your use. After you've
set everything up and your services are running, when you open the front end link
in your browser, you're going to be greeted with this onboarding flow. The first thing
you'll need is an additional API key. You can go ahead and choose between Google
Gemini or OpenAI for this. In their documentation, they've specifically listed Google Gemini and its
free models as a good alternative. They mentioned that the free rate limited models are
completely sufficient for this use case and you won't exceed the limits during normal operation.
I'm just going to go ahead with OpenAI. The reason you need to provide another
API key is for the RAG implementation. To make RAG work, the system needs to
convert the words in your documents into numbers based on their meaning. This conversion process
is what makes the search so fast and accurate and it requires a
Let me take you through the actual process that needs to be done. First, you
create a new project, like I did. After creating the project, I went into Claude
Code and asked it to search for all the projects. It fetched my project and
returned the ID along with the description. In that description, I had defined that it
should only use local storage, follow a specific architecture, and be built with SwiftUI. Next,
I told it that I wanted to build the app and provided some requirements. I
specified that it must use liquid glass and that I just wanted two pages in
the app for now. Think of this step as writing a PRD and you can
discuss this with cloud code and finalize this. You just need to focus on the
features you want. Archon can just then create the docs using the templates that I
showed you. Think of your coding agent as the tool that's only there to execute
tasks while Archon is the context box where all your knowledge and instructions live. Going
back to the process, once the documentation was ready and it had the SwiftUI knowledge
base in it, it needed to create tasks. I told it to break the work
into two cycles of tasks for simplicity. It went ahead and started generating tasks. If
you check the tasks tab, you'll see that there are tasks placed in the backlog
and the ones that done are awaiting review. Then I told it that the iOS
app I made in Xcode was already set up. and it just needed to begin
development. Using the Manage Tasks tool, Archon's MCP began executing the tasks. Now, you might
wonder how it knows when to use the documentation. Before, as you know, the big
issue was that giving some context for a single task, and many times that context
wouldn't turn out to be enough. With Archon, this problem is completely solved. The coding
agent is integrated with Archon, so that whenever it feels even the slightest uncertainty, it
automatically fetches the required documentation. Before creating tasks or PRDs, it already uses
RAG to gather context, but throughout the entire process, it keeps fetching more documentation if
needed. This way, it never relies on an inaccurate web search or the limited context
for the task. And how is this behavior built in? Well, Archon provides a rules
file. This file essentially tells the agent how to function with the Archon MCP connector.
You can get this file directly from the settings, copy the rules, and apply them
to any agent. There is one specifically for Claude Code, but the universal one can
also So
moving
on, I completed the first cycle and then I ran into a small error in
the app which is normal with Swift. It created the error as another task and
fixed it as well. I also gave it some additional instructions and it added those
as tasks as well. For example, here it needed to implement the glassmorphism effect during
the second cycle in the Polish phase. Now here, since it wasn't certain, it performed
its RAG query to search for results. It didn't find much in that, so pulled
the code examples and found some helpful implementation in that. So again, it automatically knows
when it needs to perform a RAG search whenever it's uncertain about something or doesn't
have the information. After that, it went ahead, coded everything, and completed the tasks. Now,
in a way, this is similar to what you've already seen in other framework systems
with task management, like for example, the BMAD method. In my opinion, the BMAD method
offers a better flow for coding using the agile method and there is a set
path but until that happens in this tool it's not really that beginner friendly and
you might need to experiment to find the perfect flow with this. But the amazing
thing Archon gives you is its knowledge base and that's what I'm encouraging you to
take advantage of. I'm sure that looking at this people will definitely start building more
tools on top of it and that's why I'm really excited about it. Moving into
xcode in the simulator you'll see that I had also requested a widget. The code
for the widget was completed but I had to manually add it into the app.
It can't be done automatically with a command, so I still had to do a
bit of manual work, which is why the widget isn't showing here. Other than that,
the basic app that I wanted to make was ready and I could use it.
Another thing I want you to know is that Archon is currently in its beta
version. This is the beta release and soon enough they're going to be launching the
final version. It's already scheduled, so keep an eye out for that. If there are
any major improvements in the workflow or how it's used, I'll definitely make another video
to keep you updated. That brings us to the end of this video. If you'd
like to support the channel and help us keep making videos like this, you can
do so by using the super thanks button below. As always, thank you for watching
and I'll see you in the next one.
AI coding isn’t what it used to be. Whether it’s Cursor AI or Claude Code, you’ll see that coding with AI needs more than prompts. With a RAG system in place, vibe coding completely changes. Visit Logs.so: https://logs.so/ Links: Repo: https://github.com/coleam00/Archon After seeing the limits of simple prompting, Archon changes how we think about AI coding. By combining context management with a RAG system, it creates a true knowledge hub for coding with AI. You’ll see why many now call this the best AI for coding. Whether you’re setting up Cursor AI or following a Claude Code tutorial, this workflow shows how an AI IDE coding setup can go beyond shortcuts. In fact, it highlights the best coding AI practices—like task management, real documentation, and memory handling. If you’ve ever wondered how to use Claude AI for coding or wanted a Cursor AI tutorial that actually explains the process, this guide breaks it down. I’ll walk you through Cursor AI setup, show you how to use Claude Code in VSCode, and explain where Claude Code vs Cursor really matters. From a software engineering perspective, Archon acts like the best AI agent for coding—tying together artificial intelligence, programming, and engineering workflows into one system. It’s a practical step forward for any software engineer who wants to explore coding with AI in a smarter way. Hashtags: #aicoding #cursorAI #claudeCode #AI #ChatGPT #Coding #ArtificialIntelligence #SoftwareEngineering #Programming #Engineering #SoftwareEngineer