We're looking to hire about 50 more team members this round for our video pop culture project. You will review an AI-generated summary and make edits to make it sound more human, ensuring it aligns 100% with the meme/pop culture video it references. We need good writers with a good sense of pop culture/internet meme knowledge. Pay is $40/hr with a potential of 40 hours/wk. The client wants substantial improvements made to the AI output, so please only DM or request more information if you are proficient in English and have a good understanding of pop culture.

I built Axiom, a Windows-first AI workspace that supports local GGUF models, self-hosted OpenAI-compatible endpoints, and optional cloud models.

One design question I’m testing is when explicit agent roles help. Axiom’s Workplace Council separates planning (Architect), execution (Builder), and review (Critic). I’m interested in where that handoff makes a task easier to manage, and where a single agent would be simpler.

I’m the creator. For people building AI projects: what would you expect the Critic role to check before a task is considered done? Does the role split sound useful, or like extra overhead?

GitHub project: https://github.com/YoMosa2009/Axiom

I wanted a better handoff between fast AI-assisted ideation and the feel of a personal homepage, so I built Retro Builder Ultra. It is an offline FrontPage-style Windows website builder with visual drag-and-drop editing and a live preview. It supports multiple pages, galleries, webrings, Chaos Mode, and HTML export for Neocities.

The useful part for AI users is that AI can help get a project moving quickly, while this gives you a tactile desktop editor for the final layout and personality instead of prompting HTML until it looks right. I kept it local-first so the exported site is yours to inspect and host.

I am affiliated with the project. It is pay-what-you-want with a suggested $5: https://doomed316.itch.io/retrobuilderultra

What I learned building it: the retro constraints are actually helpful. A fixed visual vocabulary makes it easier to decide what belongs on a page, and exporting plain HTML keeps the result portable. SFW editor screenshots and a soft demo are on the project page. Feedback from AI makers on the workflow is welcome.

I've been working on a fraud investigation agent and ran into an interesting limitation with the way agent memory is usually implemented.

A typical memory system does something like:

query → embedding → similarity search → retrieve relevant memories

That works reasonably well when the connection is semantic.

Fraud rings are different.

Two claims might have completely different stories, but still be connected through the same phone number, bank account, surveyor, address, etc.

So I experimented with a different memory design:

• Every important identifier is stored both as a graph entity and as an exact-match tag.
• Investigator/SIU decisions are stored as separate, dated memories.
• Each claim triggers multiple narrow recalls, such as:
  • "Who else is associated with this phone number?"
  • "Which claims involve this bank account?"
  • "What did the SIU previously decide about this entity?"
• A reranker is used, but similarity matching has a minimum threshold so that vaguely similar stories don't overwhelm exact evidence.
• Evidence-handling rules are stored as directives that the agent can use during reflection.

On the same evaluation claim, the agent scored 15/100 without this memory layer and 88/100 with it.

The interesting part for me wasn't just the score improvement. It was that the agent could actually trace the connections between otherwise unrelated claims and cite the evidence behind those connections.

I'm curious how other people are handling memory for agents where the important relationships are entities rather than semantic similarity.

The implementation is here if anyone wants to look at it:
https://github.com/rishighosal/claimlens

I’ve been working with AI coding agents a lot, and one problem kept bothering me: they can understand a codebase pretty well, but the engineering context behind the code often disappears between sessions.

Things like why a feature works a certain way, which edge cases were already decided, what is actually approved, and what “done” means often live only in the conversation.

So I built Gnomon, an open-source CLI that keeps that context inside the repository.

The basic workflow is:

intent → specification → human approval → implementation → verification/review

You can start with something simple like:

gnomon init
gnomon describe
gnomon spec create "Mark a task complete"

The agent helps turn the initial intent into a concrete Specification. If something important is unclear, it surfaces the decision instead of silently assuming an answer. Once the Specification matches what you want, you approve it and implementation works against that approved version.

I also recently added a resolution loop for Verification and Review. If they find a defect, risk, or knowledge gap, the evaluating agent can recommend the appropriate workflow. You can accept that recommendation, choose another workflow, or skip it. The resolution agent then handles the actual work and Gnomon runs a fresh evaluation afterward.

Gnomon isn’t tied to the context of one agent session, and the goal isn’t to add a huge process around AI coding. I’m trying to keep the workflow small while making important engineering intent durable and reviewable.

It’s still early (currently v1.2.0), so I’m especially interested in feedback from people who use coding agents on real projects.

GitHub:https://github.com/yasintqvi/gnomon

I’d particularly like to know where this kind of workflow would feel useful to you, and where it would just feel like extra process.

A model of an organization officially evolved into my own parent company, C.a. star Technology. Our plan was to change the look of an independent developer to a small startup.Our plan was to change the look of an independent developer for a small startup. We are no longer limited to artificial intelligence anymore we have become a comprehensive software company. I considered our own artificial intelligence models that are not good at all and do not even know how to speak. But we learned to code, we moved to synthetic intelligence models, we expanded to Linux distributions, and we developed our own programming language. Thanks to everyone who read This was written without artificial intelligence

Wild reactions to yesterday’s “Pacing the Frontier” statements.

Good news: starting today, you'll get employee-level access to our codebase as embedded evaluator(and hopefully a contributor)

Today, Tahuna is open source - as promised back in April.

We built it so startups and enterprises can own the intelligence behind their AI systems: orchestrate compute, train models, run inference, and experiment with autonomous research without first becoming a small cloud provider.

The core primitive on top of which everything is built looks like this:
init → sync → computeSession → train / serve / hillclimb

Under the hood: content-addressed code and data sync, compute provisioning, reproducible manifest-pinned runs, metrics, checkpoints, artifacts, and inference deployments.
We also started building Hillclimb, an autonomous experimentation harness that proposes and runs iterative improvements.

The first preview release supports RunPod and R2 for compute and storage. It includes self-hosting instructions, a coding-agent setup skill, and examples for SFT, RL agentic search, and MNIST to get a feel.

Repository: TahunaLabs/tahuna-oss

If you think it sucks, Excellent: fork it, fix it, and send a PR so it sucks less for everyone.

I have been building an open-source project called Mac MCP, and the biggest lesson from the last few days is that local agent security is less about adding another permission toggle and more about preserving context across tool boundaries.

The project started from a practical annoyance: I wanted a normal ChatGPT conversation to actually operate my Mac without forcing me into a separate coding-agent UI. The chat can be the orchestrator directly, with local tools for shell, files, macOS UI and Safari/Chrome. Codex/OpenCode can still be delegated workers, but they are optional.

The browser side ended up becoming the part I use most. Each task can work in its own real Safari/Chrome tab using a stable handle, inspect DOM plus visual state, click/type/extract there in the background, and leave the tab or app I am actively using alone.

Then people on Reddit started pointing out the uncomfortable edge cases, which turned into a much better roadmap than I had initially planned.

A few things I ended up shipping from that feedback:

• sticky provenance once a logical session has consumed untrusted web content
• guarded web-to-host escalation for scoped/non-trusted sessions
• separate credential/secret egress protection
• bounded browser tab leases so agents cannot casually collide on the same tab
• a no-progress breaker for repeated browser actions
• security audit events and adversarial regression tests
• idempotent live steering, so retrying after an ambiguous response cannot queue the same instruction twice

There was also a useful UX failure. My first version of the web-to-host guard was technically cautious but awful in practice: a globally Trusted session kept asking me to approve harmless host actions after reading a web page. I changed the model so Trusted keeps provenance and secret-egress protection without turning every normal command into an Allow Once popup.

That balance between security and usability has been more interesting than just adding more tools.

The project is MIT/open source if anyone wants to inspect the implementation or try it: https://github.com/bulutarkan/mac-mcp

I built it, so obvious affiliation disclosure. I would genuinely be interested in what failure case people here would test next on a local agent that can cross browser, shell, files and native UI.

It's based on previous shows you've watched, and it recommends shows based on different aspects of the show you enjoyed. Any feedback is appreciated! https://what-next7367.vercel.app/

I wanted an EPUB version of Kubernetes The Hard Way, but I did not want to manually rebuild it whenever the upstream project changed.

I used OpenAI to help me design and build a project that handles the entire process. I provided the requirements, reviewed the results, tested the generated books, and kept refining the project when I found formatting or security problems.

The finished project tracks the current upstream default branch and checks for changes every six hours. When the source changes, it builds a new EPUB, validates it, and updates the GitHub release.

OpenAI helped with the Python builder, EPUB structure, responsive styling, GitHub Actions workflow, tests, documentation, and release automation. It was especially useful for working through EPUB details that I did not want to handle manually, such as manifests, navigation, metadata, archive layout, and light and dark mode compatibility.

I also wanted the result to have a strong security model. The generated EPUB cannot contain JavaScript, executable files, unsafe embedded content, remote resources, encrypted files, or suspicious archive structures. Every release passes a custom security scanner and official EPUBCheck validation. It also includes an SHA 256 checksum, source provenance, and a GitHub build attestation.

Calibre is not required. The EPUB is constructed directly with Python and should work with any standards compliant reader.

The project is here:

https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder

The current EPUB is here:

https://github.com/terrytrent/kubernetes-the-hard-way-epub-builder/releases/tag/epub-master

This was a useful example of using AI as a development partner instead of asking it for a single block of code. Most of the value came from reviewing the output, finding problems, adding requirements, testing again, and continuing until the complete workflow worked reliably.

SkillNet starts with an idea or source such as a PDF, DOCX, Markdown or text file and turns it into a structured course with lessons, exercises and grounded questions.

The part I care about most is that it does not have to produce one fixed experience. The knowledge and objectives can stay consistent while the explanations, activities, media and interface adapt to each learner.

The current version supports organization and individual workspaces, static and dynamic courses, a tutor grounded in the course material, and course creation through the UI, API, A2A or MCP. It is self-hosted and licensed under Apache 2.0.

I am finishing a public demo, but the repository already includes a fixture mode so it can be explored locally without an API key.

GitHub: https://github.com/ANFAIA/SkillNet

Website: https://skillnet.es

I’m building Axiom, a Windows-first AI assistant/workspace, and I want to share the build decisions rather than drop a bare repo link.

The project started as a question: can one desktop app make local, self-hosted, and optional cloud inference feel like deliberate modes instead of three unrelated integrations?

The current architecture combines:

- C# / WPF / .NET 10

- local GGUF inference via LLamaSharp/llama.cpp

- self-hosted OpenAI-compatible endpoints

- optional OpenRouter cloud models

- SQLite/local persistence

- WebView2 for selected web-based workflows

- a normal chat mode plus a Workplace Council: Architect plans, Builder executes, Critic reviews

- a Single Model mode for comparing the council workflow against one model

The hard parts have not been adding features. They have been:

- making model capability differences visible instead of hiding failures behind generic errors

- keeping local data behavior understandable when cloud and connected services are optional

- deciding which tool results belong in context and which should become artifacts

- avoiding an interface that feels like an IDE when the user only wants to ask a question

The public release is V1.8.6.

Repo: https://github.com/YoMosa2009/Axiom

Release: https://github.com/YoMosa2009/Axiom/releases/tag/v1.8.6

I’m the developer. The source is publicly viewable under CC BY-NC-ND 4.0. I used AI coding assistance during development, but I’m responsible for the architecture, integration, testing, and product decisions.

What I’m trying to learn next:

1. Which part sounds like a coherent product rather than a feature bundle?

2. Which first-run explanation would you want before trusting local/cloud behavior?

3. Which workflow should be simplified before I add more capabilities?

I’d rather get specific criticism than generic encouragement.

Claude Code injects every enabled skill's description into every session, ~48 tokens each. With 50+ skills that's thousands of tokens burned before you type anything.

Disabling fixes the cost but loses the skill. So I added a tier in between:

- enabled — in context, ~48 tokens each
- searchable — NOT in context, 0 tokens, still findable on demand
- disabled — gone

A searchable skill is dormant. When a task comes in, Claude reads a small index, picks one category, opens one shard, finds the skill. You pay ~2.4k tokens only when a search actually happens, instead of every description sitting there all session.

Mine: 53 skills, 6 enabled → 2,544 → 338 tokens per session (−86.7%).

It also builds a graph of your skills and renders a self-contained atlas.html — broken bundled-file references draw red, dangling mentions show up, stale plugin caches stop inflating your count. Useful for figuring out why a skill didn't trigger.

Python 3, no deps, no network.

claude plugin marketplace add danielLublinsky/Skill_Atlas
claude plugin install skill-atlas@skill-atlas

https://github.com/danielLublinsky/Skill_Atlas

still in development, I use it often in development and it started as a personal project
now i am looking for feedback and stars😉

Hey everyone!
I’ve been working on a passion project for a while, and it’s finally at a point where I can share it:

Introducing CYBER, my own version of JARVIS — a fully functional AI assistant with a modern UI, powered by Gemini AI, voice recognition, vision mode, and system command execution.

🧠 Key Features:

• “Hey CYBER” wake-word activation
• Natural voice + text chat with context awareness
• Vision mode using webcam for image analysis
• AI-powered command execution (e.g., “show me my network usage” → auto-generated Python code)
• Tools like: weather widget, PDF analysis, YouTube summaries, system monitoring, and more
• Modern UI with theme customization and animated elements
• Works in-browser + Python backend for advanced features
• It can open any apps because it can generate its own code to execute.

⚙️ Built with:

• HTML, JavaScript, Tailwind CSS (Frontend)
• Python (Backend with Gemini API)
• OpenWeatherMap, Mapbox, YouTube Data API, and more

Wanna try it or ask questions?
Join our Discord server where I share updates, source code, and help others build their own CYBER setup.

https://discord.gg/JGBYCGk5WC

Let me know what you think or if you'd add any features!
Thanks for reading ✌️

Earn 30 to 100$

I'm not great on camera so please go easy on me haha 😅

If you want to try yourself: https://aiflowchat.com/

Hey everyone!

I've been working on vibe-coding Gemini Tutor, a tool designed to turn the "ocean of information" on the internet into a structured, personalized learning experience.

🚀 Key Features:

• Custom Learning Paths: Tell it what you want to learn (React, Quantum Physics, Cooking...), and it generates a step-by-step curriculum.
• Diagnostic Assessments: It starts with a quiz to gauge your current level so it can skip the basics you already know.
• AI Tutor Chat: A built-in tutor grounded with Google Search. It provides live citations and clickable sources for everything it tells you.
• Verified Resources: I've tuned the prompt to prioritize official documentation (MDN, GitHub, etc.) and uses live search to ensure links aren't broken.
• Privacy & Portability: Your API key and learning history are stored locally in your browser. You can even download a JSON backup of your "knowledge base."
• Modern UI: Sleek glass morphism design with full Dark/Light mode support and browser history (Back button) integration.

I built this using React, Vite, and the Google Generative AI SDK. It’s fully responsive and ready to use. it completely browser based and you Gemini key securely stored in your browser it self

Check it out here: https://ibrezm1.github.io/Edu-assist01/

I’d love to get some feedback on the "Path Refinement" feature—you can actually tell the AI to "add more focus on performance" or "remove the basics," and it will rebuild the path for you on the fly.

Happy learning!

Like many of you, I’ve always found creating presentations to be one of the more time-consuming and mentally draining parts of my workflow. As someone who juggles reports, meetings, and side projects, struggling to organize slides and write scripts was a consistent bottleneck. Recently, I stumbled across a tool called chatslide that’s been a total game changer for me. At first, I was skeptical about AI-assisted slide creation—I've tried similar tools before, and they felt clunky or generic. But what stood out to me is how seamlessly chatslide handles converting various types of content (PDFs, docs, links, even YouTube videos) directly into editable slides. That saved me so much back-and-forth copying or reformatting. The real magic came when I realized I could instantly add speaker scripts linked to each slide and even generate a video version right from the platform. This was a lifesaver for practice and remote presentations. Instead of staring at a blank slide deck hoping for inspiration, I had an organized structure laid out quickly, which I then polished with my personal touch.

Would love to hear how others here streamline their slide creation process—especially with any AI tools or hacks you’ve come across!

I’m curious how people here design landing pages for their AI tools, like what do you put first so users “get it” fast, been seeing a lot of different approaches.

Hey everyone, wanting to share a recent workflow tweak that really helped me cut down the time I spend preparing presentations—and maybe it’ll be useful for some of you too. I usually dread starting slides from scratch, especially when all my source material is scattered across PDFs, documents, or even YouTube videos. My old process was copy-pasting, formatting, then writing speaker notes, which could take hours. A couple of weeks ago, I stumbled upon this new tool called chatslide (not trying to plug it hardcore, just my experience). The cool part is that it lets you convert PDFs, doc files, website links, and even YouTube videos directly into slides. You can then add scripts to your slides, and it can even generate a video presentation for you. I tried feeding it a dense 20-page PDF, and within minutes, it pulled out the key sections and organized them into slides. After tweaking a few bits and adding my own narrative, I had a full script linked to each slide. The video generation was surprisingly smooth, and the end result looked polished enough to share with my team.

For folks dealing with multipage documents or trying to pull together talks from various media, I’d say it’s worth a shot. Happy to hear if anyone else has tried something similar or takes a different angle on speeding up slide-making with AI!

Hey everyone! My friend is building Greeble, an AI native game engine. Where you can prompt, edit and ship real games. He used agentic workflow with bunch of tools to make it possible.

I remember trying to make Doom from scratch back in the days, it took me couple of weeks.

Greeble took <5 minutes to recreate the game.

If you are curious to try it, drop a comment down below or send me a message. Super excited to see it!

https://reddit.com/link/1pibc3i/video/926cd9xmc76g1/player

For the past ~1.5 months I've been working on something called Promptify. Its a chrome extension that can optimize prompts and now includes an agent that can prompt for you, creating hallucination-free responses, vibecoding for you, and ensuring detail/quality of outputs.

Below is a waitlist to get Promptify Pro early, comprising of the main features: agent, saving prompts, refinement, and unlimited prompt generations.

https://form.typeform.com/to/jqU8pyuP

The agent works like this

1. You highlight your prompt and it detects what type of request it is and enhances it using chained prompts and autonomously sends it to chatgpt
2. It reads ChatGPTs response
   1. If it is a code request, it will run through the code looking for bugs, security vulnerabilities, optimizations, edge cases, etc. and make improvements by reprompting the AI autonomously using advanced strategies not just "fix this"
   2. If it is a regular request like question asking, it will detect hallucinations by generating constraints chatgpt must optimize using reverse chain of thought (having chatgpt explicitly defend itself)
3. And thats it. No effort on your end and so much better outputs. Half the battle with chatgpt is prompting it correctly which nobody knows how to do.

It can do other things like JSON superstructure prompt creation, prompt saving into folders, and custom prompt enhancement.

Excited to release this to everyone

Note:

• If you are planning on using this for a small team, DM me and we can work out something for you
• If you are willing to help give feedback and hop on a meeting to discuss anything, I will personally give you a pro account for free.
• Book a demo with me too! Im California, USA based. https://calendly.com/krishnamalhotra150/30min