Anticodeguy

<written by a human being>

What tooling do professional video creators use today for AI-generated video? For example, if the task is to 'shoot' a mini-series on a specific topic, with characters and a ready-made script? I know there are standalone models and web apps built around those models - Kling, for instance. There are also aggregators that let you choose from different models available on the market for generation, like OpenArt, Artlist, and others. There are tools that let you build generation pipelines by calling the right models via API - ElevenLabs Flows, for example. You can spin up open-source models and work with them directly. Which of these? And yes - I've done several researches using AI agents, but never got a real answer.

One AI-coding skill to rule them all

<written by a human being>

If you asked me for one simple recommendation for vibe-coding - something not deeply technical but still capable of noticeably improving the quality of your work - it would be Superpowers. This is a plugin for Claude Code built by Anthropic themselves (the creators of Claude), so I can recommend it without the risk of picking up something sketchy like prompt-injection tricks for your agents. Superpowers is essentially a collection of skills for coding agents that helps you approach development in a structured and systematic way, following best practices and using a full toolkit that includes clear planning, code review, and other good engineering workflows. You can install it with the command:

/plugin install superpowers@claude-plugins-official

or simply find it in the Claude Code plugin menu. By the way, Superpowers can also be used in Codex by giving it this command:

Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

<written by a human being>

We're used to delegating repetitive physical work to machines and mechanisms. Now we're slowly learning to hand off some of our cognitive load to AI agents. At its core, sitting and typing things into documentation is routine, monotonous work. Today, that's becoming a thing of the past too - thanks to the system I described in my previous series of posts. And all you'll be doing now is talking to your agent, sharing your thoughts with it. Like, you tell it that this particular document was done wrong, and please make these specific changes. It's basically your personal assistant that handles everything for you. The most important thing when working with an AI agent is to make sure that after any changes - whether to local files or Notion - it always syncs them first, and second, commits and pushes to GitHub at the end of each session. This matters specifically for keeping everyone in sync who's involved in editing that knowledge base. If that's not happening, just explicitly ask Claude to update its memory and add the necessary instructions - you'll need to update the claude.md file and, naturally, push those changes to the repo for the agents of your fellow meatbags. So working with a knowledge base is getting simpler and more fun. After this kind of setup, you end up with a fully synced knowledge base that you can comfortably share with coding agents, without ever leaving the familiar Notion interface.

AI Built My Own Multistream Server in a Few Hours

An AI Agent in Your Notion Knowledge Base

<written by a human being>

Now let’s move on to the fun part. The most important benefit of using this entire setup - which at first may seem fairly complex - is worth highlighting again. We are talking about synchronizing a Notion knowledge base with a GitHub repository and local files so multiple people can work together at the same time. After all the preparatory steps are completed, you can continue working with Notion exactly as before: edit documents the same way you normally would, and simply ask the AI agent after each session to synchronize the changes with the repository so that all other participants can see those updates. For the agent, “synchronizing with the repository” should also mean that the repository is pushed to GitHub. This is an important detail that should also be added to the agent’s memory and included in the instructions inside claude.md (or agent.md). But the most interesting part is that you can assign tasks to the coding agent related to working with your knowledge base - and even dictate ideas to it directly. For example, you can ask it to improve a document, or simply speak your notes into the chat and then instruct it to structure those thoughts and distribute them across the appropriate documents. The AI agent will determine on its own where everything should go, how it should be recorded, and in what format.

Pros and cons of AI-syncing a knowledge base in Notion

<written by a human being>

I forgot to mention one important thing that actually makes this whole sync setup for multiple people working in the same knowledge base (Notion) make sense - it's the ability to use the completely free version of Notion, which only works for one user. In our case that's fine, because changes can be committed independently from each other - you just need to tell the AI agent about it. The constant need to sync documents is, of course, a downside. There's a real chance you'll forget to do it. You can do it less often, but it's important to understand that if several people are working with the documentation at the same time, the more frequent the sync, the more up-to-date the knowledge base will be, because there's a risk that one document gets edited by people from different places - and that's the biggest risk right there. So everyone needs to understand how to properly sync files. And the whole thing still looks pretty janky - obviously a minus, but right now it's the best solution I could come up with for collaborating in a single Notion account, one that more or less replicates the logic of Git repositories, just with a manual drive. But at the very least it gives you the ability to work with documents comfortably in familiar Notion. And on the other side - to work with that same knowledge base using AI agents. That's the beauty of it.

How can you work more optimally with AI coding agents

How to sync your local files with Notion using AI agents

<written by a human being>

After we asked the AI agent to sync files between Notion and the local repo, we need to check the result. Go into Notion, see that each file now has a separate block with a link pointing to the destination address in the repo. Then go into the local files and make sure they also have the Notion file ID they belong to. So the files need to be linked bidirectionally. That's exactly what gives you the understanding of how to work with them. The workflow from here is simple. Whenever you change something in Notion, you just open Claude Code and say: "Sync changes for this file." You can pass the ID directly, or just the name - the agent will find the file and pull in all the updates that were made. If something goes wrong - like the document got deleted or whatever - the agent will ask what to do. Feels like extra overhead at first, but there's really nothing scary about it, because the moment you notice some data drift, you can fix everything with literally one call. If multiple documents change throughout the day, you can do a sync at the end of the workday. Or go further and set up an automation in Notion that triggers the sync every hour or every day - it'll check all the diffs between documents in Notion and the local repo and sync the files.

How to sync your local files with Notion using AI agents

<written by a human being>

When we work with a Git repository, it's basically a file sync system that keeps the full history. You can look at every stage - every commit, meaning every file change - and see exactly what was done, by whom, and when, so that all those changes are reversible. That's the whole point of a Git repo. When we work with a knowledge base like Notion in tandem with a GitHub repository we set up ourselves using AI, doing sync automatically won't work - because it would eat a ton of resources (AI tokens, meaning money) just to check the current state every time something changes. We can do it through the API, set up an agent, but in my opinion that's massive overkill and it's gonna chew through a lot of resources. Since we're not working with documents 24/7 and they're not changing constantly at high frequency, a manual push of all changes is gonna be more than enough. How to do it? Tell Claude the following: "Set up two-way document sync between Notion and a local Git repository. When changes are made in Notion, they should be reflected in the local documents. And vice versa - if I edit local documents, they should be pushed to Notion. The push should happen on my request. On your end, you need to organize sync by document identifiers." Every document in Notion and every document in the local repo has an identifier that links it to the corresponding document in the other system. Meaning Notion will have the filename with its repo path that the document references. And vice versa - every text document in the repo will have a link with that file's identifier in Notion. Obviously, having the identifier is what lets the AI agent update that file via MCP. Claude (and any other agent) will understand what's meant here - even if right now it sounds complicated and technically confusing or unclear.

Open-source software is getting its second wind nowadays

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