Three Skill Packs Worth Trying for AI-Assisted Development
Practical recommendations for using Agent Skills, ECC, and Emil Kowalski’s skills to improve engineering workflows and interface quality.
An AI agent adds a feature. The application starts, and the interface looks convincing. But nobody has checked the error paths, mobile behavior remains untested, and the reasoning behind an architectural decision is buried in a chat.
This is where skills can help: reusable instructions that guide an agent through a clear process. They prompt useful questions, direct verification, and call attention to details that are easy to miss when writing code quickly.
To explore this approach, I recommend three open repositories: Agent Skills by Addy Osmani, ECC by affaan-m, and Skills by Emil Kowalski. Each brings a useful emphasis: engineering discipline, agent workflows, and interface quality.
Agent Skills: From a Task to a Verified Change
Agent Skills provides workflows for requirements, planning, implementation, testing, review, and release. The collection also covers API design, debugging, security, performance, and documenting decisions.
Its emphasis on verifiable outcomes is especially useful. Skills include steps, checkpoints, and evidence requirements such as test results, build output, or observations from a running application. Verification becomes part of the task from the start.
For a new API endpoint, for example, an agent can clarify the contract, implement a small complete scenario, check error handling, and review the change. Each stage produces something a developer can assess.
I would start here if you want more consistency in everyday agent work: fewer repeated instructions in chat, and more changes accompanied by clear reasoning and verification.
ECC: Tools for Organizing Agent Work
ECC is a broader toolkit for AI-assisted development. It combines skills, specialist agents, commands, rules, and hooks. The repository includes integrations for Claude Code, Codex, and other environments; available features depend on the host and installation method.
Its workflows cover feature planning, architecture, code review, build fixes, testing, and documentation. Treat it as a catalog of processes you can select for a particular project.
My recommendation is to adopt it gradually. Start with one recurring task, such as checking changes before a commit. Observe which instructions the agent applies and whether the result is useful. Then add another workflow.
Hooks deserve a separate look: they are scripts triggered by events in the host environment. Read what they do before enabling them, and verify their execution afterward. Check the documentation for your integration to understand which hooks are available and how they behave.
Emil Kowalski Skills: Attention to the Interface
Emil Kowalski's collection focuses on interfaces, animation, and interaction details. It helps agents choose motion parameters, review existing animations, identify useful opportunities for motion, and build UI variations for comparison.
The repository includes skills for the web, React Native and Expo, mobile behavior, Apple's design principles, and Swift. The break-ui skill exercises interfaces with edge cases such as long names, large counts, empty lists, and unusual data.
This is a useful collection once the main flow works and you are ready to examine the experience closely. How does a menu open? Does motion get in the way of repeated actions? What happens to a long button label? Is the screen comfortable to use on a phone?
I recommend it to developers who want to give visual refinement the same attention they give application logic. Specific rules and checks make interface discussions more concrete.
Using the Packs Together
This division of responsibilities is my suggested workflow. Compatibility between individual features still needs to be checked in your chosen host.
For a new feature, you could follow this sequence:
- Clarify the task and acceptance criteria using Agent Skills' engineering workflows.
- Select appropriate ECC workflows for implementation and verification.
- Review the interface with Emil Kowalski's skills when the change affects user interaction.
- Verify the result in the running application and retain the findings with the change.
Start with a small task whose outcome is easy to assess: a form, a settings screen, an API endpoint, or a known bug. Compare the completeness of verification, the clarity of the change, and the amount of rework.
All three collections overlap with other project instructions. Establish where mandatory engineering rules live, which checks are required, and who accepts the result. Skills should support that structure.
Follow the installation instructions for your AI client. Copying individual skills and installing a complete plugin can expose different capabilities. Check supporting files, avoid duplicates, and preserve local edits before updating. For team use, pinning a version or commit makes changes to the workflow deliberate.
The most practical first step is to choose one useful workflow from each repository and apply them to a real task. That will reveal which instructions actually help your work.
The Next Step: Keep Engineering Rules with the Project
Once you have useful workflows, the next challenge is to keep them alongside the architectural knowledge, constraints, and checks for a particular repository.
As a next step, I also recommend exploring my project EmbrAIon. For me, the value of this direction is continuity: useful processes should remain clear and accessible as tasks, sessions, and tools change. A good foundation for AI-assisted work helps a team preserve that structure and develop it alongside the project. You can find the details and links on the EmbrAIon project page.
EmbrAIon
An open-source AI-First Engineering System that keeps project instructions, agent roles and validation checks in your repository. Use the same project rules across supported AI coding tools.
GORYNED · GitHub · Open Source
Topics
- Software Design
- Testing
