And the future with libraries like Charm or Ratatui having wrappers for Ruby I think the future to build TUI with Ruby is getting closer.

See more examples here https://allaboutcoding.ghinda.com/essential-ruby-gems-for-working-with-agent-skills-files

I want to see more gems or libraries built with #Ruby to provide a great foundation of DX. Ruby is a scripting language too but also a web development language.

3️⃣ agents_skill_vault

A gem that can manage a vault (a local folder) with various skills from Github URLs

Basically you can give it a list of Agent Skills (or repositories) and it will download and sync them on a local folder.

https://github.com/lucianghinda/agents_skill_vault

The code created for them was generated using a combination of Claude Code + GLM via Claude Code, OpenCode and Moltbot

I reviewed all the code and manually refined it until I got a version that is good enough for release.

2️⃣ agent_skill_parser
A Ruby gem for parsing skill files that use YAML frontmatter and markdown body content.

It will parse an AgentSkill file according with specifications from agentskills dot io and return an object with those properties

https://github.com/lucianghinda/agent_skill_parser

1️⃣ agent_skills_configurations

A unified interface for discovering and accessing skill configuration paths for various AI coding agents.
It will give you the configuration location/folder per each installed (or not) AI coding agent.

https://github.com/lucianghinda/agent_skills_configurations

Here I have created a couple of gems as a foundation for creating more tools to support agents in Ruby. I know there are already packages in JS or other languages, but I wanted to have a couple of tools written in Ruby to be included in other (more complex) DX tools.

For engineering leaders: the study's conclusion matters for your teams.
If your developers rely heavily on AI for code generation, you need processes that ensure they understand what's being generated.
During incidents or debugging sessions under pressure, they need those skills

I saved my notes that I shared here at https://notes.ghinda.com/post/few-personal-notes-from-the-how-ai-impacts-skill-formation-from-anthropic

Read the original paper and article from Anthropic here:

Article: https://www.anthropic.com/research/AI-assistance-coding-skills
Paper: https://arxiv.org/html/2601.20245v1

Another key insight: encountering errors and debugging them plays a crucial role in skill formation.

The control group (no AI) hit errors, had to understand why they happened, and learned through fixing them. This can't be fast-tracked.

Debugging and incidents are essential parts of becoming a better developer. These experiences build the mental models you need.

AI can help you explore codebases and libraries during debugging, but it shouldn't replace the process of understanding why something broke.

Throwing a zero-shot prompt at AI about an error is still a dice roll. Sometimes it works, sometimes it doesn't.

Few-shot prompting with specific context, possible root causes, and hints about the codebase helps. You need to understand the problem first to provide that context.

2. Ask AI to generate code AND provide explanations in the same response

These participants spent more time reading but developed better understanding. The explanation forced them to engage with the concepts, not just copy the solution.

But here's the practical part. The study found two approaches that worked well for both completion and comprehension:

1. Generate code with AI, then ask follow-up questions to understand what it did

This group showed strong understanding in their quiz results.

The core finding: developers who completed tasks without AI assistance scored higher on comprehension tests.

Using AI to generate code doesn't automatically translate to understanding that code. This held true across all experience levels.

This matches my experience. When I use AI to generate code unless I make an intentional effort I forget about that code very quickly.

I need to actively review the code, build a mental model, and trace through the logic. Without that effort, I'm just copying and pasting.

One interesting finding from their pilot: even when explicitly told not to use AI, 25-35% of participants still did.

This shows how deeply integrated AI has become in some workflows. We reach for it almost instinctively now.

ChatGPT agrees with me:

For me looking at this table seems like most of them were senior developers. Maybe it is typo/bug in the article they published.