Supercharge OpenCode With 1300+ Free Skills in One Command Makes It 100x Powerful

So, Open Code is already a capable tool.

It runs in your terminal, connects to any LLM provider you want, has a plan mode, a build mode, undo and redo support, and it handles real code bases without much setup. But the default

install is just the base. There's a free open- source repository that plugs directly into Open Code and gives it over,300 expert level skill files covering everything from architecture

planning and React patterns to API security auditing and infrastructure setup. That's what this video is about.

setup. That's what this video is about.

We're going to install it, configure it for Open Code specifically, and build something with it so you can see the actual difference it makes. The

repository is called Anti-gravity Awesome Skills, and right now it's sitting at version 9.1A with over 28,000 GitHub stars and more than 4,000 forks.

The name says anti-gravity, but it works natively with Open Code, Claude Code, Gemini CLI, Codeex CLI, Cursor, Kira, Adal CLI, and GitHub Copilot. This video

focuses specifically on the Open Code setup, so that's where we're going to spend our time. So actually when you prompt open code to build or plan something without any additional

context, the agent uses its general knowledge to figure out what to do. That

works fine for simple stuff, but for anything with real structure, proper component architecture, security aware APIs, test-driven workflows, the output

tends to be generic. Skills close that gap. Each skill is a skill.md file that

gap. Each skill is a skill.md file that gives open code structured instructions for a specific domain. The agent loads a skill on demand when you reference it, follows its instructions for that task,

and the quality of the output reflects the expertise baked into that file, and because Open Code uses a native skill tool under the hood, it only loads what

you actually ask for. No wasted context.

So, let's install this. Open code looks for skill files in a few different locations. The path you want for the

locations. The path you want for the anti-gravity awesome skills repo is aagents/skills at the project level. This is the npx command which we have to run with path

flag. In path flag, we can define the

flag. In path flag, we can define the exact path where open code looks for skills. If you are using any other

skills. If you are using any other tools, this can change according to that tool. So run that from the root of your

tool. So run that from the root of your project and it drops all the skills into that folder. If you want a global

that folder. If you want a global install, so the skills are available across all your projects without copying them each time. You can point it to the global agents path, open code will

discover skills from both the project level folder and the global folder automatically so you can mix and match.

If you also have aopenode/skills folder set up, open code checks that too. It walks up from your current

too. It walks up from your current working directory to the git routt and loads anything it finds in those paths.

After the install, verify it worked by opening open code and type /skills. This

will show you all the available skills if installed correctly. If you see these skills, then it verifies that we got all the skills. After this, in your project

the skills. After this, in your project directory, we can run /init if you haven't already. That command analyzes

haven't already. That command analyzes your project and creates an agents.md

file which helps open code understand your codebase structure and coding patterns from the start. You should

commit that file to git. So, you're set.

Now, one thing to know about how Open Code handles skills internally, it lists all available skills in its native skill tool description. Each skill shows up

tool description. Each skill shows up with its name and a short description so the agent knows what's available before you even ask. When you reference a skill in your prompt, Open Code calls that

tool, loads the full skill.md content,

and applies it to your request. This is

different from dumping everything into context up front. The agent makes a deliberate choice to load a skill when it's relevant. Now, let me talk through

it's relevant. Now, let me talk through what's actually in here because the skill count alone doesn't tell you much.

The architecture category has skills for system design, C4 diagrams, architecture decision records, and scalable component patterns. If you're starting a project

patterns. If you're starting a project from scratch or making a significant structural decision, this is where to begin. The business category has

begin. The business category has copywriting, pricing strategy, and SEO audits. more relevant if you're building

audits. more relevant if you're building a product and not just writing code for someone else. Data and AI has skills for

someone else. Data and AI has skills for rag pipelines, LLM app design, agent orchestration, and prompt engineering, which is useful if open code is part of

a stack you're building AI products on top of. Development covers language and

top of. Development covers language and framework expertise, TypeScript, Python, React patterns, and more. General has

your planning and documentation skills like brainstorming and doc co-authoring.

Infrastructure handles Docker, AWS serverless, Verscell deployments and CI/CD pipeline setup. Security is a strong category, API security, SQL

injection testing, vulnerability scanning, compliance checks and hack tricks. Testing covers TDD workflows,

tricks. Testing covers TDD workflows, test design, and QA automation. Workflow

covers orchestration tools like ingest and trigger.dev for async jobs and background processing. The repo also

background processing. The repo also classifies each skill by trust level.

Official skills come directly from Anthropic Google Versel Microsoft Superbase, and other vendors. Safe

skills are community-built and non-destructive. You can check the

non-destructive. You can check the catalog before running anything you're unsure about. There are also bundles

unsure about. There are also bundles which are curated skill lists grouped by role. Web wizard covers React, Tailwind,

role. Web wizard covers React, Tailwind, and front-end design. Hacker Pack,

penetration testing, and vulnerability scanning. Product pack covers planning,

scanning. Product pack covers planning, SEO, and strategy. Essentials covers

clean code, planning, and validation, the basics that apply to almost any project. You install everything once,

project. You install everything once, and use the bundle as a reading list to figure out which five or six skills are most relevant to what you're working on right now. All right. So, let me

right now. All right. So, let me actually demonstrate this inside open code. I'm going to build a project

code. I'm going to build a project dashboard using three skills in sequence. I'll use brainstorming, then

sequence. I'll use brainstorming, then front-end design, then react patterns.

This is a realistic workflow, not a toy example. I open code in my project

example. I open code in my project directory and hit tab to switch to plan mode first. That's a key habit with open

mode first. That's a key habit with open code. You want to review the plan before

code. You want to review the plan before building anything, especially on a new feature. Then I prompt, "Use

feature. Then I prompt, "Use brainstorming to plan a project management dashboard. I want a sidebar

management dashboard. I want a sidebar with navigation, a stats overview section with metric cards, a task list with filter controls, and a recent activity feed. Stack is React with

activity feed. Stack is React with TypeScript and Tailwind." The

brainstorming skill doesn't just start writing components. It asks clarifying

writing components. It asks clarifying questions first. It wants to know if

questions first. It wants to know if this is a standalone page or part of a larger app, whether data is mocked or wired to a real API, and whether mobile responsiveness is required. I answer

each one. Then it produces a planning document with a component hierarchy, state management approach, folder structure, naming conventions, and which external libraries to reach for. This is

the kind of document that normally takes a developer 30 to 45 minutes to put together before writing a line of code.

Now I hit tab again to switch back to build mode and follow up. Use front-end

design and react patterns to build this dashboard based on the plan we just made. After I clicked send, it started

made. After I clicked send, it started working out systematically step by step.

After some time, it finished working.

What comes out is properly structured.

There's a sidebar component with typed navigation props. There are individual

navigation props. There are individual stat card components with separate props for the label, value, and trend direction. The task list has filter

direction. The task list has filter state managed correctly at the right level in the component tree. The

activity feed is its own isolated component. Everything is typed with

component. Everything is typed with TypeScript. No logic is crammed into a

TypeScript. No logic is crammed into a single file. The folder structure

single file. The folder structure matches what the brainstorming document outlined. That's the actual value. Open

outlined. That's the actual value. Open

code on its own would give you a working dashboard. Open code with these skills

dashboard. Open code with these skills gives you a dashboard that a senior developer would not need to refactor before shipping. The difference is not

before shipping. The difference is not the model, it's the instructions the model is following. After the front end is working, I run one more skill API security best practices on the backend

endpoints I plan to connect this to.

Even before connecting anything, this skill scans what I've told it about the API shape and flags things like missing input sanitization, unguarded routes, and token handling issues. It generates

a short report. This is the kind of review that would normally happen in a code review cycle, but it happens before the code even exists in production. One

more thing worth mentioning, skill creator. This is a skill that helps you

creator. This is a skill that helps you build your own custom skills from scratch inside open code. If your team has internal conventions, a specific database naming pattern you always

follow, or a deployment process that the model doesn't know about, you can use skill creator to turn that into a proper skill.md file. It walks you through the

skill.md file. It walks you through the structure, tells you what to include, and produces a file you can drop into your skills folder and reference exactly like any built-in skill. Over time, as

you add more of these, Open Code gets increasingly familiar with the specific way your team works, and the output gets more consistent. So, the getting started

more consistent. So, the getting started guide is at getting started.md in the repo. The usage guide with prompt

repo. The usage guide with prompt examples for Open Code specifically is at usage.md. If you're on Windows and

at usage.md. If you're on Windows and hit a truncation issue, there's a Windows truncation recovery guide in the docs folder. The whole repo is MIT

docs folder. The whole repo is MIT licensed, actively maintained, and every skill file is readable, so you know exactly what you're running before you run it. All right, so that's it from the

run it. All right, so that's it from the video, and I hope you enjoyed it. If you

did, please like this video and subscribe to the channel.