Anticodeguy

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

<written by a human being>

How to make AI and systems analysis work together After the primary materials are collected, the real fun begins. You need to prepare all of this so that artificial intelligence can actually work with it. In this case, I have no interest in using a simple chat format, because chat has a context window limited to that specific chat session - and it will get completely stuffed just from processing a single meeting transcript. These are typically multi-hour meetings that need to be held in context, and processing files like that burns through a massive number of tokens. Literally after a couple of passes, or a couple of follow-up questions in that same chat, every limit I currently have access to will be torched. How do you avoid this? First: for processing large volumes of materials, we won't be using chat mode - we'll be using coding mode. For Claude specifically, that's Claude Code, which you activate in the app through a dedicated Code tab. Or, if you're working through the command line - which is how I do it most of the time when I'm actually writing code - you open a terminal: PowerShell or Command Prompt on Windows. Bottom line: if you want to process a lot of files with AI - coding mode is where you need to be.

<written by a human being>

We continue the saga of systems analysis with AI and Claude. This time I decided to take a more comprehensive approach and do systems analysis with Claude from the ground up, from the very beginning of the modeling process. This process starts with processing all the raw materials available at the input. When you need to produce a description of business processes, you gather artifacts - working documents, procedure descriptions, existing business process diagrams, job descriptions, all the information systems the business uses, because they're a direct representation of the objects and functions needed for various processes to operate. For example, take a database - it contains a list of the objects that participate in business processes, and from those you can already build the first object map. And from the functions of the information system you can build the first function map. In my case these elements hadn't been gathered yet, but what had already been gathered was a huge number of transcripts from meetings (calls) with the client in interview format - which contain the information we're looking for about the business, the processes, how everything works, who's involved, and so on. That's actually what business process modeling in systems analysis usually starts from.

Migrating Knowledgebase With AI [Part 7] - Finale

<written by a human being>

Wrapping up the knowledge base migration from Notion to another system - gotta say, Sonnet 4.6 handled it perfectly, no need to bring in more powerful and more expensive models (like Opus). The AI agent itself ran for just over 20 minutes, so total calendar time the task took around 40 minutes, but I personally worked on it no more than 15 minutes, everything else happened in the background. I got one question from the agent and then the final result. If I'd done this manually, it would've taken me at least an hour and a half, maybe two hours minimum of cognitive load - two tabs open at once across two monitors, hunting down each document and dragging it under another document, trying to reproduce the structure. And I definitely would've screwed something up somewhere, missed something, forgotten something, not seen it, not been able to find it, and so on - because with that kind of monotonous work there's a tendency for attention to blur out, and it's just genuinely heavy cognitive load. But when you do it with code, there's confidence that everything was done clean - because the algorithm doesn't make mistakes in this case: it either stops with an error, or it executes the defined sequence of actions precisely. And that's exactly the class of tasks I'm happy to delegate to AI. Successful algorithm execution to you, and good luck working with AI!