Shiguredo Inc. is a technology company specializing in WebRTC SFU Sora as its flagship product. Their development skill set and workflow have gained attention based on official sources as of June 2026. Shiguredo’s skills center on Erlang as the primary language, combined with Python, Rust, and TypeScript for practical implementation. This enables building high-performance WebRTC infrastructure and efficient development processes.

📑Table of Contents
  1. What are Shiguredo’s Skills?
  2. Skill List and Features of Each Language
  3. Development Flow (create-issue → polish-issue → review-diff-code)
  4. Effects of Skill Utilization and Combination with AGENTS.md
  5. Frequently Asked Questions (FAQ)
  6. Summary and Implications for Readers

What are Shiguredo’s Skills?

Shiguredo’s skills refer to the collection of development conventions and tool usages established and maintained internally. The main goal is to standardize issue-driven development processes and streamline code reviews and implementations using LLMs. According to the official site, these skills are directly tied to the core development of WebRTC SFU Sora and require daily maintenance.

Why is this skill set important? In modern software development, consistent quality management across multiple languages is a challenge. In Shiguredo’s case, they achieve both performance and development speed by layering specialized skills in other languages on top of a reliable Erlang/OTP foundation. In actual operations, combining with AGENTS.md supplements LLM judgment capabilities, concentrating human roles on “final decisions.”

For example, the shiguredo-erlang skill supports Sora’s core logic, while shiguredo-python handles testing and bindings. This combination enables stable development even for complex real-time communication systems. Sources: Shiguredo official website (https://shiguredo.jp/) and the author’s blog (https://voluntas.ghost.io/shiguredo-skill-20206-06/, published June 20, 2026).

In conclusion, Shiguredo’s skills are not just coding conventions but cover the entire workflow suited to the LLM era. We encourage readers to consider them as a reference for their own projects.


Skill List and Features of Each Language

The main skills used by Shiguredo are as follows. They use Erlang as the base and differentiate by language according to purpose.

Skill Language Main Uses Features
shiguredo-erlang Erlang WebRTC SFU Sora core High availability leveraging OTP
shiguredo-python Python pytest, nanobind, PyO3 Testing and high-performance bindings
shiguredo-rust Rust Performance-critical modules Safety-focused with many “do not use” notes
shiguredo-typescript TypeScript Browser Vite/Preact Modern frontend development

From this table, the roles per language are clearly divided. Erlang handles the core for stability, Python for flexible scripting and testing, Rust for critical performance parts, and TypeScript for user interfaces.

The reason is that in real-time systems like WebRTC, division of labor leveraging language characteristics is essential. For instance, Sora’s core uses Erlang’s lightweight processes for concurrent processing, while the browser side uses TypeScript for interactive UIs. The official source (https://shiguredo.jp/) also emphasizes that these skills are updated daily.

Specific effects include cases where Python-Rust integration using nanobind and PyO3 resolved bottlenecks. Source: Shiguredo official website (as of June 2026) and the voluntas.ghost.io article.

In conclusion, this skill list serves as a model case for multi-language projects. Readers should compare it with their own tech stack and consider similar divisions of labor.


Development Flow (create-issue → polish-issue → review-diff-code)

Shiguredo’s development flow consists of an issue-centric process. Specifically, the steps are:

  1. Create issue with create-issue
  2. Polish with polish-issue (shortest ~30 minutes using Opus 4.7)
  3. Human review
  4. Skill-based implementation
  5. review-diff-code for 3-5 rounds of review (from 7 perspectives)
  6. PR creation, review, and merge

This flow is effective because it incorporates LLM assistance at each stage while inserting human judgment. In polish-issue, LLM refines the issue; in review-diff-code, differences are verified from multiple angles. This reduces rework and improves quality.

As a practical example, the 7-perspective review systematically checks security, performance, readability, etc. Combining with AGENTS.md allows LLM to identify points to point out in advance. Sources: voluntas.ghost.io June 20, 2026 article and Shiguredo official information.

In conclusion, this flow is a good example of LLM-utilizing development. Readers may consider introducing it as issue templates in their projects.


Effects of Skill Utilization and Combination with AGENTS.md

Shiguredo’s skills maximize LLM effectiveness when combined with AGENTS.md. AGENTS.md is an instruction document for agents that guides code generation and reviews in conjunction with skills.

Effects include shortened cycles from create-issue to review-diff-code, improving development speed. Wrappers like update-skills for gh skills aimed at non-technical users are also provided, enabling team-wide utilization.

Why effective? LLMs alone are prone to judgment errors, so skills impose constraints and AGENTS.md provides context. This allows humans to focus on “judgment” tasks. The official blog states that skills maintained daily form the foundation.

Example: Running review-diff-code for 3-5 rounds enables early detection of potential bugs. Source: https://voluntas.ghost.io/shiguredo-skill-20206-06/ and https://shiguredo.jp/.

In summary, the combination of skills and AGENTS.md is a practical development model for the LLM era.


Frequently Asked Questions (FAQ)

Q: Are Shiguredo’s skills publicly available?

No, they are for internal use only under Shiguredo management. Not publicly disclosed. Source: Official information (https://shiguredo.jp/).

Q: Which language skills are the most developed?

Erlang is the most developed as the foundation, with Python, Rust, and TypeScript prepared by use case. Strengths particularly in testing and performance.

Q: How long does polish

issue take? A: Shortest around 30 minutes using LLMs (e.g., Opus 4.7). Human review ensures quality.

Q: How many rounds of review does review

diff-code involve? A: Typically 3-5 rounds. Verified from 7 perspectives.

Q: How are the skills maintained?

Daily maintenance and improvement are performed, optimizing LLM utilization in combination with AGENTS.md.


Summary and Implications for Readers

Shiguredo’s development skills and workflow are a prime example of modern development utilizing LLMs. With Erlang at the core and multi-language differentiation, they maintain quality through an issue-driven flow. We encourage readers to build skill sets suited to their projects and introduce guides like AGENTS.md. Refer to the official site (https://shiguredo.jp/) and related articles to aim for efficient development.

Related articles:

krona23

Author

krona23

Over 20 years in the IT industry, serving as Division Head and CTO at multiple companies running large-scale web services in Japan. Experienced across Windows, iOS, Android, and web development. Currently focused on AI-native transformation. At DevGENT, sharing practical guides on AI code editors, automation tools, and LLMs in three languages.

DevGENT about →

Leave a Reply

Trending

Discover more from DevGENT

Subscribe now to keep reading and get access to the full archive.

Continue reading