Anticodeguy

How can you connect another person to your knowledge base

<written by a human being>

Once the repo sync is done (read previous post), ask Claude to read the claude.md file (or agent .md for other agents) in that repo, get familiar with the project, do all the necessary setup according to those instructions, update its memory. Right there you can also send the API key from Notion. If the user whose machine we're setting things up on has a separate Notion account, you'll need to log in as them, go to Notion integrations settings, create an API key, copy that token, and hand it to Claude - so it has everything it needs to start working right away. The agent will do everything specified in the file, read the project docs, figure out which MCPs need to be configured, update its memory, handle the setup. And after that you're good to go. For a cold test, ask the agent to tell you about what this project is, what tasks are currently on the table, or any other question that'll show you how much context your coding agent actually has right now. That's basically it, you can start working on the project - just don't forget to ask it to sync docs with Notion so they stay up to date.

How can you connect another person to your knowledge base?

<written by a human being>

At this stage, I think it’s already clear that you can begin working with the knowledge base using a coding agent on your local machine, and there’s nothing complicated about that. You simply write prompts, assign tasks, review the results, and make corrections. All standard document-related work can already be carried out normally from this point onward. However, it becomes interesting when you connect another person who will have access to the same knowledge base and effectively the same coding-agent setup, allowing both of you to work on the project synchronously. So, what we need to do is go to the local computer of the person who will be working with this knowledge base and repeat the same steps we initially performed on the first computer. The only thing that does not need to be done again is collecting the materials, since they have already been gathered. You need to create a folder and launch the coding agent from it. After that, we need to synchronize the repositories. This is done, of course, by adding collaborators to the repository. You should go to GitHub, and if the second person doesn’t yet have a GitHub account, they need to create one and then be invited to your repository. Once the recipient accepts the email invitation, the repository will become available to them. After Claude Code has been launched from the correct folder where the repository should be located, we need to ask it to synchronize this folder with the Git repository and provide the repository link, which can be copied from the browser. If Git is not installed on the computer, the agent will first perform all the necessary setup steps. After that, you’ll need to authenticate with GitHub. This is usually done through the browser. Once authentication is completed, the files can be pulled - Claude will do this automatically - and you will find all the files from the GitHub repository in the folder. Essentially, half the work is already done at this point.

Make an AI agent write instructions for other AI agents

<written by a human being>

Before starting work on an AI project that involves collaborative work (in a single repository), give Claude Code a task to create a claude.md document, put all the necessary instructions in it for independent work of another coding agent that will also connect to this repository and that should fully understand all the context and all the rules of work. Also make sure to include MCP setup instructions there, meaning if besides Notion some other MCP shows up here, you need to include it there too. But the main thing is that on first launch the coding agent running from another machine understands that it needs to set up MCP before starting work. So basically, reading claude.md will be the very first initiating prompt, which is exactly what a person joining the shared repository should do. I recommend reading this сlaude.md file and checking if everything there is specified correctly. If something is missing or structured not the way you see it, or some information there is inaccurate, for example about project goals or something else, fix it. But overall claude.md should already be in its final version, in which it should be read by another agent. After the document is ready you'll need to make the first commit and push to Git, meaning send all the documents there. This we also just ask Claude to do, and it independently syncs everything with the GitHub repository.

How to get $1,354 worth of Claude Code for $100

Configuring a knowledge base to work with multiple AI agents used by different people

<written by a human being>

An important step is to create a claude .md file that will be used not only by you in this repository, but also by other participants who will collaborate with you on this knowledge base. This is a key element that will make it possible to build a knowledge base capable of synchronizing the work of multiple people. Claude’s memory (I mention Claude as an example, but this applies to other AI agents as well) is stored locally within each project. So when another person joins your knowledge-base repository in Git (which is exactly why we created it there), they will be able to download the files from it, but naturally there will be no memory available for the Claude agent that the other person is using. To fix the structure of the data, define what the project is about, and establish working rules, we will create a claude .md file - a markdown-formatted document that will contain all the necessary instructions for working with the project for any coding agents. In this example it is called claude .md, which works well if you are using Claude Code specifically. For other agents, the file can be named agent-instructions .md - a more neutral option that avoids referencing a competing agent directly. After all, who knows what their creators may have built into them.

<written by a human being>

Now that MCP is set up and verified, you can start the actual work and give AI agents their first tasks. For example, the first task in a project like this would be something like "sync all the text files currently in the project locally with Notion, reflect the document structure in Notion and add the appropriate descriptions." If you have text (or markdown) documents, they need to be moved to Notion. Make sure to specify that they should be moved with proper formatting. If these are documents of a different kind - images, archives, or whatever else - if they can be inserted into Notion, let it insert them, if not, just make a description of them. Basically, create a documentation and file registry that you and your agents will always have in front of you in Notion. This is also important for properly onboarding the project and always having the current context available. A note on formatting in Notion. There might be some confusion here - with Claude, for example - about MCP working as an API that just accepts flat text, so it'll send documents as plain text with no formatting. By default only headings and lists will get applied. But actually, if you send already markdown-formatted text through MCP, Notion will parse it correctly - the AI agent just doesn't know this by default. So it's better to explicitly tell it as an instruction, and ask it to update its memory with the information that the Notion MCP supports full formatting. Otherwise the text your agent creates in Notion will just be flat and painful to read.

How I Fixed 502 Bad Gateway for My Client Using AI

Setting up MCP Notion for a coding agent

<written by a human being>

Go to Notion, open Settings -> Connections section, find the link Develop or manage integrations. In the left menu pick Internal Integrations and hit Create a new integration. Here you set the Integration name, pick the Workspace you want to connect your AI agents to, and click Create. In the window that opens go to the Content Access tab and pick the Workspace or specific documents that'll be accessible via API (in our case MCP). And finally, on the Configuration tab there's an Internal integration secret field with Show / Copy buttons - that's how you grab the key that opens the door for your AI agents into Notion. Important note. Claude itself has a built-in Connector with Notion. but that's not what we're after. We want the full-blown MCP, which is what our coding agent will talk through - any agent, not just Claude Code. And the agent already knows how to set up MCP. All we need to do is give it the right prompt: "Set up MCP with Notion that will have maximum possible access to the workspace, token [API-token]". And send it the token you just copied from the integration you created in Notion. Then ask the agent to test the connection. Like add some document, edit another one, move it, delete that same test document and whatever other actions you'd normally do in Notion. Once that's done, ask the agent to update its memory so all the MCP info is available to it, because it checks memory on every single prompt. Meaning whenever any execution process for a given task kicks off, the agent will check memory for relevant instructions. Which is exactly what we need.

<written by a human being>

If you haven't worked with Git repositories before, now's the perfect time to start. All you need to do is go to GitHub or GitLab - depending on your personal preference (they're essentially the same thing) - and create a new repository. The repository can be public or private, again, depending on your project. I usually create private repositories so I don't expose them unnecessarily before the time is right. The repository itself should be empty: don't create anything inside it, including what the Git service suggests by default. Once the repository is created, you need to sync it with your working directory on your local machine. You can do this yourself via the command line. Or you can ask an AI agent to handle it - just send it the repository URL and ask it to sync with the folder it was launched from. This is the key point: we need to be working in coding mode. Meaning this is Claude Code or Codex running from the command line, or - if you're working from an app - in Code mode. And the coding agent must be running from inside the project folder, where all the project files are located and where the repository will live. The prompt looks something like this: "Sync the current folder with the repository [repository link]" - and here you paste the link to your repository.

I like working with AI agents

Sync your AI projects with a Git repository

<written by a human being>

So, we created a local folder where we placed all the project documents following the defined structure. As an example, I'll be looking at building a business knowledge base, which is a solid case study when it comes to working together with AI and other people. Next step - we need to sync this workspace with a repository on GitHub or GitLab, depending on your preference. The key thing here is - with a repository that other people (and agents) can join and that you can share with them. Why do you need this? As long as you're working with a knowledge base (or any project) solo, you can skip this step. But the moment you start working with at least plus one person, you already need to share this knowledge. In that case it becomes way more convenient to work in a Git repository format, which allows you to, first, add new people to the project and, accordingly, share the common repository with the whole set of files stored there. And second, clearly track changes, because Git is a versioning system across all files in this repository. Meaning it's always visible who made what changes and at what stage, with the ability to roll it all back.

Complex Projects and AI Agents [#AI-Notes]

<written by a human being>

At the first stage you gather absolutely all artifacts and files that relate to the project. After that I recommend doing the following. Suggest to the AI agent to go through all the files that were uploaded and do a surface-level breakdown of what these files are, what they represent, and understand how they relate to this project. And, if needed, put them in order. What do I mean? If there are a lot of files, maybe directories got mixed up and they're placed not in accordance with the project's file structure logic. Maybe it's better to rename them. For example, add the file creation date as a prefix, apply unified naming. And at this stage you can also suggest to the agent to develop a special naming convention for this project, which will be used for naming all files. So your prompt goes something like this:

I added files to the project folder. Go through all these files from the perspective of matching the established file structure and put them in order if needed. Move to the right directories, add missing directories and rename files so it's more convenient to work with them going forward. Based on project knowledge, propose a naming convention that makes sense to you and rename files according to it. But clear the convention with me first.

The approval step here is critically important. If what's happening is only understood by the agent, but you don't understand it, then working with this project is gonna be hard. It's important that the understanding is shared and that you agree with the established convention. The result of this stage is a fully structured, ready-for-further-work folder with artifacts, documents that you can start processing and that you can already apply to specific tasks, including with the help of the agent. We'll get to that next. The next stage is syncing with the GitHub repository.

<written by a human being>

Important observation when working on projects with AI. After creating the project folder, you need to fill it with the most relevant context possible. Most likely you've already started creating some documents, files before. Maybe it's a Word doc where you write down thoughts about the project, maybe it's notes in text format, working documents, presentations. In my case, for example, it was a big set of call transcripts and meetings with a partner we were discussing the project with. All of them should be placed into the created folder. Since we've already taken care of the file structure inside this project earlier (see previous posts), it's important to place all documents into the right folder right away. For example, for transcripts, if you wrote the task for the AI agent correctly, a separate 'transcripts' folder will be created, with two subfolders 'raw-transcripts' and 'processed-transcripts' - the ones that have already been processed and will contain meeting summaries. So you need to start following the established structure right away. It's not the AI agent working here yet, it's you on your own - you'll have to switch on your cognitive apparatus to do this. But again, if you're having trouble or not sure where to place a particular document, you just go into the AI agent, continuing the same session where the structure was developed, and ask which folder to put specific documents in. And if there's no such folder, it'll suggest creating one and updating its memory, adding the new folder to the structure. And now the agent will have an understanding that there's a new type of files that will be involved in the project, and they're sitting in the corresponding directory.

What real things have I built with vibe-coding - Part 3

<written by a human being>

Simple but extremely important task for you and the agent - develop a file structure for the project. The main input for this task will be the information you give it as initial data, again, just dictate everything you know about the project. The output should be a list of folders with hierarchical nesting that needs to be created in the project folder. A good practice is to indicate at the end of the prompt that if some details are missing, something is unclear, or there are gaps in thinking, in the project description, then preliminary clarifying questions should be asked. You can also add that it shouldn't make stuff up and hallucinate things that weren't explicitly stated. Then we take the specified file structure. As a rule, it'll be accompanied by some brief description of the project itself that we'll be implementing. And create folders based on this structure in our project folder. Or, if you're really too lazy, then in this case we go into Claude Code or Codex, and launch the coding agent from the target folder and paste everything we wrote above as the initial prompt. And give the task to create the structure in this folder right away. That's what our agent will be doing at the first stage.

How can complex tasks be solved with the help of AI?

<written by a human being>

To do this, you need to open Claude or ChatGPT in chat mode, choose a reasoning model or a model with extended thinking capabilities, and dictate a description of the project to the model if it does not yet exist in any text format. Yes, I intentionally used the word "dictate" here, because when we write, we usually try to write very briefly and concisely. In principle, this is the ideal approach, but with complex tasks there is often no structured workflow pattern for the project at the beginning, so I prefer simply explaining things in speaking mode. It’s easier and faster. It doesn’t matter if I repeat some things several times. The most important part is that several paragraphs of text that I dictate will be correctly understood by the AI, because it handles context very well. For me personally, this significantly speeds up prompting compared to typing characters, if I can simply dictate everything instead. For dictation, you can use the built-in functionality available in some AI tools. For example, ChatGPT has this feature out of the box. Claude doesn’t have speech recognition yet, but tools like Wispr Flow can be used to dictate and instantly transcribe your speech into text.

What real things have I built with vibe-coding - Part 2

<written by a human being>

The very first step, even before launching Claude Code or Codex, or any other agent, is to create a folder on your computer for your project. If there's nothing in it yet, you need to fill it with files and folders first. The moment we start talking about folders, the question of structuring that space immediately comes up - because it matters, for both any agent and any human, to know where each file lives, so you don't get lost in them, so there's a clear, strict hierarchy, and following that hierarchy is how we'll manage all the project documentation. This is critically important, because it massively simplifies and speeds up the work. The AI doesn't need to do a contextual search through documents to figure out what's in them - which is what happens when you just dump everything into one folder. But when there's a defined structure, it helps us navigate the files ourselves, and naturally, the agents too. You can develop this structure on your own, but if the project is complex in any way, you can also do it with the help of AI. To do that, open Claude or ChatGPT in chat mode, pick the thinking model or one with extended thinking in reasoning mode, and describe the project to the model - if it's not already written down somewhere in text form - asking it to generate a file structure for the project.

<written by a human being>

When you start working with a coding agent (the most well-known ones being Claude Code or Codex) there's a key moment - you need to pick a working repository. That's the place we'll work with documents and basically any materials for the project from. If we're building some kind of program, application, website - it's obvious to any developer that we need a repository to store the codebase, and our AI agent will work with that codebase. But when we need to do cognitive tasks - like systems analysis tasks, for example - technically there's no repository until we actually start building an information system based on the analysis we ran. But what I'm suggesting is to flip this approach and use a repository not just as a folder for the codebase, but as a project folder that any AI agent we want to work with will operate from. Meaning - we have a repository even when we're not writing code, just when we're working with AI. Like if we want to use it as a systems analyst, a business assistant, or whatever else - doesn't matter. For any role you assign to your agent, you need a working project. I know this is already being done with RAG, or Retrieval Augmented Generation, but we're not gonna complicate things here - we'll just make a regular human-style repository, or just a folder with files, and point our agent at it so it can fully immerse in the context.

What real things have I built with vibe-coding