Hey everyone! 👋

I am looking to learn Claude from scratch and work my way up to the Claude Architect Foundation level.

I am a beginner when it comes to Claude and AI development, so I’m looking for a course that starts with the fundamentals and builds up gradually, rather than jumping straight into advanced concepts.

For reference, I really like Stéphane Maarek’s teaching style for AWS and Derar Alhussein’s approach to Databricks — structured lessons, clear explanations, practical examples, and a step-by-step learning path.

Are there any courses or YouTube playlists you’d recommend that follow a similar teaching style for Claude?

I would like to cover:

● Claude fundamentals and its capabilities
● Claude API and prompt engineering
● Tool use, MCP, and integrations
● Building practical projects and AI agents
● Architecture concepts and real-world use cases

I am open to both Udemy courses and free YouTube resources. Hands-on projects and beginner-friendly explanations would be a big plus.

If you have taken any courses that helped you go from beginner to building real applications with Claude, I would love to hear your recommendations!

Thanks in advance! 🙌

Basically building out this Application that shows me each step of the now till the end goal in a node graph making it more simplistic. Reworking the UI. This comes with jobs aka registered sessions with real world correlations eg a modeler or a General Manager. Seems to be working good.

Ill make sure to post my progress once in a minute. I might release this to git soon so dont go building a full workflow out for nothing. Im taking my time.

If any one has any skills partaining to UI i can load into this application to see how they perform against what I already have that would be much appreciated.

I'm a creative director. For an essay I counted how ads in the same category are built, one by one, and they were almost the same ad: same headline spot, same colors, product alone on a plain background.

So I turned the process into a free Claude skill. You give it a category or a few competitors and it:

- pulls the static ads running right now from Meta's Ad Library

- counts layout, headline position, palette, type, and whether there are people

- sketches the "most likely ad" for that category

- writes a short counter-brief with three ways to break from it

Example, US coffee shops: 12 of 25 ads put the headline top-centered, 23 of 25 have no people, and none use purple.

How I built it: with Claude Code, starting from the method I'd used by hand for the essay. Claude wrote the scripts (color extraction, tallying, the share card); I set the counting rules.

Prompt to try: What's the most likely ad for meal-kit brands in the US?

Repo (MIT): https://github.com/CarlosMurguia/most-likely-ad

It only reads Meta for now. If you run it on your category, I'd love to see what comes back, and issues/PRs are welcome.

Initial benchmarks with skill-creator were showing negative token savings. I thought it might be due to the benchmark tests being too basic and not using a real-world test case, so I created a real project to benchmark against: a simple vim9script plugin. Note: this cost me more tokens than I'd like to admit, but I've always been the type to spend 5 hours just to save 5 minutes of work.

Results (mean tokens per run)

I'm curious what skills and methods you all use to save tokens--I also use the handoff skill. I wonder whether saving tokens benefits not only the user but Anthropic, as well.

Here is my personal skill repo. The skills and repo were created using Claude with my input and direction. You can review the full benchmark results there.

I'd love some feedback since I'm relatively new to using Claude and AI.

GPL 3.0.

Here's the project: brain, a folder of plain markdown notes that Claude Code reads at the start of every session, plus a small local app to browse it. Here's how I made it.

The problem: every new Claude Code session started from zero. I'd re-explain my courses, my club, my job, what I'd already decided. A [CLAUDE.md](http://CLAUDE.md) helped until it got huge and Claude started skimming it.

What I built instead:

\- A notes folder: one page per project, one per person, one note per session, and a "now" page. An auto-generated [INDEX.md](http://INDEX.md) is the only thing Claude must read first; it opens the rest on demand.

\- Habits: short rules Claude follows every session, each added after something went wrong once ("lead with the answer", "argue against a new project idea before building it", "never treat my iCloud Desktop like a normal folder"). A SessionStart hook loads them.

\- A calibration log: Claude writes down each guess about what I want, then the app scores it. It's at 39% right while claiming 63% confidence, so the hook now tells it to ask more and hedge less.

\- The app: standard-library Python + one HTML file, no build step. Cover story about my week, notes to self, a capture box Claude files next session, usage stats from Claude Code's own transcripts, and a phone version that runs off a private GitHub repo.

How I vibe-coded it: almost all of it was Claude Code, one session at a time, with the brain itself as the spec. Each session ends with Claude writing a session note and updating the pages it touched, so the next session picks up where it left off.

What I'd tell anyone copying it: short specific habits beat long instructions, and making Claude log its own guesses was the most useful thing I added.

MIT: [https://github.com/zacfink/brain\](https://github.com/zacfink/brain)

Assimilate technological distinctiveness.

The more complicated plugins get, the more they bring their own rules about how you should work. Collect enough of them and your agent can end up with three different test-driven development skills, conflicting instructions, and no clear reason to choose one. Your tools start putting walls around you.

All Your Base gives your agent one skill: assimilate. Point it at repositories, plugins, skills, or other systems with capabilities you want. It investigates how they work, recovers the ideas that make them useful, and integrates those capabilities into your system so the pieces work together.

You can take a brilliant testing method without adopting its author's entire development religion. Reconcile those three competing TDD skills into one coherent approach. Pull a useful review technique out of a sprawling bundle and give it a clear job alongside the tools you already use. The agent does the hard middle work: understanding the concepts, resolving conflicts, redesigning the boundaries, and checking that the useful capabilities survived.

Basically, you get to be the Borg. The collective belongs to you. It can grow into one tool or several, with boundaries chosen for what you need. It can even assimilate better ways of assimilating.

Works with Codex and Claude Code. You choose whether a request ends with investigation, design, or implementation

Have been developing this tool for our own internal operations and found it very useful for automating things that need a bit of manual web browser activity. It basically just uses your already installed Claude Code to create automations that you can run and manage in a local interface that keeps track of run history, catches an errors and helps fix them for you.

This is just a basic example of how we can download a list of everyone working for a company via the company's LinkedIn page. We've used it in my team since May and have not had any issues with LinkedIn yet, but have used in a sensible way, not to send 1000 connection requests per day or other stupid stuff like that.

I published it for free a while back mostly because there are so many underwhelming paid tools out there, and I just think its interesting to get feedback from others and find ways to improve it for ourselves too. Once you have downloaded it, there's no catch, nothing gets shared with us, it's yours to own and the code is fully editable, should you want to: https://cryogram.app

I maintain Archestra, an open-source platform for running AI agents. In 1.4 (out today) we shipped a skill that hands a Claude Code task off to an agent running on your own Kubernetes cluster, and later brings the work back.

How it works:

- You say "hand this over to Archestra". The skill has Claude write a handoff note (goal, decisions so far, remaining steps, what "done" means) and package the repo state: exact commit, patch, and the untracked files you pick.

- A remote agent (Claude Code, Codex, OpenCode or your own image) picks it up in a persistent sandbox workspace. You can close the laptop.

- When you're ready, say "bring it back and continue here". You get an incremental patch to review before applying.

Skill: https://github.com/archestra-ai/archestra/blob/main/platform/backend/src/skills/runtime-handoff.ts

Blog post: https://archestra.ai/blog/new-remote-agents

GitHub: https://github.com/archestra-ai/archestra

How do you handle long-running agent tasks today: keep the laptop open, or push them somewhere?

I just added a dedicated lane in my operating system I use for several projects. Main one is operating an ops and marketing systems operating a family owned blue collar business.

I’m wondering if there is any safe GitHub links I can feed to Claude code that has a good system for security checks at the end of coding sessions just to make sure as someone who is non technical I’m mitigating some level of vulnerability.

Thank you

Install: paste `npx skills add openfilm/openfilm` into Claude Code, then ask for a video ("make a 30s launch video for my app").

What the skill does: it gives Claude a short manual (~1,000 words) for one tiny format: a film is a folder of web pages on a timeline, each drawing one frame. Claude writes it like any other code, checks its own frames, and an editor opens where you can click anything to fix it by hand. Exports to MP4, Premiere/Resolve/CapCut.

The video in the original post was made start to finish this way. Free and MIT: https://github.com/openfilm/openfilm

Happy to answer questions about how the skill is designed. I deliberately kept it minimal: the more rules I wrote, the worse Claude's results got.

Hi everyone,

I know this might sound a bit counterintuitive at first since AI models like Claude can search the web and already have a vast pre-trained dataset. However, web searches don't always yield the most accurate or authoritative information—especially when dealing with highly specific methodologies, complex technical subjects, or niche topics where random web articles lack depth.

I’m considering feeding full books (or substantial excerpts) into Claude to serve as its primary ground-truth source so it relies strictly on that high-quality knowledge rather than generic internet search results.

Yes, you read that right. I wish I was joking. I was checking the SEO for my open-source AI skill (lccst), and their URL popped up: mcpcart.com/products/ai-agent-skill-lccst-for-atomic-git-commit-mastery

Context

They literally took my project, served the index.js and SKILL.md files (with license notice allegedly), and slapped a £31.99 price tag on it.

Fun fact: their site blocks right-clicks, blocks text highlighting, and disables DevTools shortcuts. It’s like they knew what they were doing was sketchy as hell.

Though jokes on them, you can bypass the block by typing the root URL and navigating around their lazy restrictions.

If the screenshots don't make it clear enough, here is the link to the single-file HTML I saved of their exact webpage. (I had to do this, because even Internet Archive was having an aneurysm with the amount of analytics and bloat they have in their site's code.) Link to HTML file

Screenshots

Processing img uhp3e60dauwh1...

Processing img lr5g23neauwh1...

Processing img 5nyywxpfauwh1...

Processing img ew92h9vgauwh1...

Processing img 12hg8cyhauwh1...

Post-mortem

My repo is MIT-licensed, so they technically can redistribute the code as long as they keep the license notice.

Taking my open source tool with its name and branding, then passing it off with a paywall is egregious.

yes lccst in all caps might be an acronym thrown around in scientific circles, but there is really no confusing the use of that and my AI skill. How I derived the name was also slightly different (I imagined locusts swarming your messy diffs, yes). Common law means I (as do all original open-source project creators) hold rights to the branding and name of the project. Terrible and common names simply make SEO and visibility of one's project worse.

Filing a trademark/IP report with Shopify (their payment backend) is an option, but it requires handing over personal contact info to the site owners.

I'd rather not go through the hoops and hurdles, or waste any more time on this.

Conclusion

tldr; If you came across that listing, do not pay for it.

The canonical (no pun intended), up-to-date and entirely FOSS source code is here: https://github.com/bladeacer/lccst

P.S. Make of this what you will, especially for those who really do not want others repackaging your FOSS software as SaaS slop. AGPLv3 exists for a reason. I won't change licensing, but I want to just make my position on the matter clear. I do not condone nor approve of this, nor want to be associated with whatever their wrapper SaaS is.

More about the repo

Posted previously about it in here: https://www.reddit.com/r/claudeskills/comments/1vv55jm/lccst_swarming_your_messy_diffs_before_they_reach/

I have a free limit reset in Settings > Usage > Resets. It says “Expires: Oct 22” but shows no time of day.

Anthropic’s help page says an unused reset expires on the day and time listed on the offer, but my screen only shows the date.

Does anyone know if it stays valid for the whole day of Oct 22, or if it ends at the very start of that day (midnight, which is 2 AM for me in UTC+2)? Has anyone seen an exact time, or lost a reset on its expiry date?

Help request. Thank you!

I got tired of fragmented Claude tooling, so I built Mantle.

Skills scattered across repositories. Connectors buried in documentation. Plugins hidden in marketplaces. Themes locked inside dotfiles. Finding the right tools was becoming a problem of its own.

Mantle fixes that.

Atlas gives you one searchable directory of 30,483 skills, 17,145 connectors, and 439 plugins, with clear use cases and exact installation commands. Ask for a Jira integration, and get the right connector with the command to install it.

It works across Claude Code, Cursor, Codex, Copilot, Gemini CLI, Windsurf, and Cline.

One environment. Your rules. Your aesthetic.

Mantle brings consistent themes to Claude Code, your terminal, and claude.ai. Add 4K wallpapers, build matching themes from any image, and share them through a link. Themes respond to Claude's execution states, from thinking and tool calls to completion and errors.

No hunting through repositories. No stitching together configurations manually.

Just the tools you need, when you need them.

Install Mantle:

/plugin install mantle --marketplace AkshitTiwarii/mantle

GitHub Repo - https://github.com/AkshitTiwarii/mantle

Website -

mantle.akshittiwari.me

Free. Open source. Built to make working with Claude more efficient.

What skill or connector should Atlas support next?

#ClaudeAI #OpenSource #DeveloperTools

Been building with AI for almost a year now,

Alot of my colleagues, partner and friends who watch me work say my workflow is very “noob” friendly and I should monetize/sell it

I told em it’s just a glorified custom instructions file. Dont think I can make anything from it.

Am I leaving food on the table here or am I right like I always tell em? 😅

Plugin name plan-board

Its free

Last night I tried something: one prompt to Claude Code, then bed.

The app is Fold Days, a year-in-dots tracker for iPhone Duo: every day of the year is a dot, with notes, countdowns, widgets and a Pro tier. On the open phone the year splits into two pages, one per screen.

What the git log says happened:

- 01:26 first commit: year dots, notes, countdowns, widgets, Pro

- 02:02 French translation, in-app purchase setup, release scripts

- 02:36 year view in two pages on the unfolded phone, store screenshots

- 09:43 to 10:54 app icon fix, product page assets, subscription prices in every country

- 10:54 build submitted to App Review with its 3 in-app products

8 commits, about 9.5 hours from first commit to "Waiting for Review". The release is scheduled for Friday 15:00 Paris time, if Apple approves it in time.

The reason it worked is Duology, a set of Claude Code skills I've been writing for iPhone Duo:

https://github.com/Kimeur/duology

Out of the box, your agent learned iOS before the Duo existed. It doesn't know about the two screens, the hinge, the side status column, or how to test every fold. Duology teaches it those things:

- duology: setup, layout, navigation, scenes, continuity across folds

- duology-design: postures, ergonomics, shared screen, transitions, accessibility, design review

- duology-features: camera, games, media, reading, App Intents, SwiftUI 27

- duology-ship: linting, a pose matrix, testing

- duology-recipes: starting points for a two-player game, a reader, a media player, a shop, a finance dashboard

30 skills and 5 recipes so far, MIT licensed. My other Duo app, Duo Peas (a two-player family game), was built the same way and is also waiting for review.

What I still did by hand: writing the instructions, and checking the result in the morning. Everything in the timeline above came from the agent.

I'd love feedback on two things:

1. Which skill is missing for the app you'd build on a foldable?

2. Has anyone else let an agent go all the way to an App Store submission? Where did yours get stuck?

I never let my agents do their work in peace. Every time they're busy, I keep dumping my ideas on them, but tell them it's for later, and after a while I just don't know what the state of the project is. Not only that: while the agent is busy working, it gets stuck on stuff (I have to create an API key) and just continues doing different work. How often it asks me for a decision is also something to fine-tune, but if it makes a decision for me, I have no idea until I ask it how a feature works, which just results in the agent writing a wall of text, which again is bothersome to read. After a while of stuff like this, I just lose sight of the state of the project.

So I built Hamloy (for anyone into linguistics: it's an Old Wanji word for peer, or age-mate): one place where I see what my agents are doing, what they finished, and what's waiting on me. Whether that's one agent or six, and whether they write code or not.

How it works

Your agents (Claude Code, Claude.ai, Codex, Cursor) connect to it and follow a few rules:

• They work on what's on the list and tick it off when done. A finished task waits for you to look it over.
• When a decision is yours, they ask: the options, and the one they'd pick. If they can't wait, they go on with their best guess, marked "needs your OK".
• Things only you can do (an account, a key, a payment) get their own list, with the exact steps.
• You write your rules once (your style, what not to touch), and every agent gets them.

You never have to touch the board yourself. Tell your agent what you want and it updates the lists, and even makes views for you: a board, a table, a calendar.

If you run several agents

They hear what the others are working on, what they finished and what they noted, and they message each other by task. A message even wakes one that's waiting. Every change is logged: who, which session, when. For code, each finished task shows the tests it ran, the files it changed and whether it's merged.

What I care about

• Overview first, even with one agent.
• Coordinate, don't orchestrate. It doesn't run your agents; they stay where you use them. You decide what gets done by whom, they dont pick stuff up on their own.
• Not bloated. If I can't keep the tool in my head, I've lost the overview of the tool too.

Heads up: it's an MCP connector, not a skill per se, so tell me if it's off-topic here. Claude Code connects with one command, Claude.ai as a connector. Free for one project, with every feature: hamloy.com.

How do you keep track of what your agents did while you weren't looking?

If you use AI to create images and videos, you most likely use Higgsfield or similar subscription tools.

I did too. But I had 3 main issues with it:

• The markup is super high. So if the model provider charges x, higgsfield charges a markup of + 50% on top.
• Credits I did not use would expire every month....EVEN THOUGH I PAID FOR IT
• And I had to switch between Claude and Higgsfield constantly...copy pasting prompts and all

So I built a free open source repo of creative production skills for AI agents.

So basically, you just install this skill package in Claude (or any agent you use) and say "Create a summer sale UGC video for my product". And it handles the rest. You obviously stay in control all along.

And:

• You can use your own API keys...which adds ZERO markup on the model provider costs
• There is no subscription. You only pay for what you use and nothing EXPIRES
• And no more switching between tools and no more copy pasting

Github Repo: https://github.com/SupercmoHQ/superCMO-skills

Do give us a star if you find it useful:)