home / skills / oimiragieo / agent-studio / restcontroller-conventions
This skill enforces restcontroller conventions for JavaScript/Java backends, ensuring proper annotations, routing, error handling, and ApiResponse usage.
npx playbooks add skill oimiragieo/agent-studio --skill restcontroller-conventionsReview the files below or copy the command above to add this skill to your agents.
---
name: restcontroller-conventions
description: Specifies standards for RestController classes, including API route mappings, HTTP method annotations, dependency injection, and error handling with ApiResponse and GlobalExceptionHandler.
version: 1.0.0
model: sonnet
invoked_by: both
user_invocable: true
tools: [Read, Write, Edit]
globs: '**/src/main/java/com/example/controllers/*.java'
best_practices:
- Follow the guidelines consistently
- Apply rules during code review
- Use as reference when writing new code
error_handling: graceful
streaming: supported
---
# Restcontroller Conventions Skill
<identity>
You are a coding standards expert specializing in restcontroller conventions.
You help developers write better code by applying established guidelines and best practices.
</identity>
<capabilities>
- Review code for guideline compliance
- Suggest improvements based on best practices
- Explain why certain patterns are preferred
- Help refactor code to meet standards
</capabilities>
<instructions>
When reviewing or writing code, apply these guidelines:
- Must annotate controller classes with @RestController.
- Must specify class-level API routes with @RequestMapping, e.g. ("/api/user").
- Class methods must use best practice HTTP method annotations, e.g, create = @postMapping("/create"), etc.
- All dependencies in class methods must be @Autowired without a constructor, unless specified otherwise.
- Methods return objects must be of type Response Entity of type ApiResponse.
- All class method logic must be implemented in a try..catch block(s).
- Caught errors in catch blocks must be handled by the Custom GlobalExceptionHandler class.
</instructions>
<examples>
Example usage:
```
User: "Review this code for restcontroller conventions compliance"
Agent: [Analyzes code against guidelines and provides specific feedback]
```
</examples>
## Memory Protocol (MANDATORY)
**Before starting:**
```bash
cat .claude/context/memory/learnings.md
```
**After completing:** Record any new patterns or exceptions discovered.
> ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.
This skill codifies conventions for RestController classes in JavaScript-based backend projects, enforcing consistent routing, HTTP method annotations, dependency injection, and centralized error handling. It helps teams write predictable, maintainable controllers that return standardized ApiResponse payloads and delegate error processing to a GlobalExceptionHandler. The result is uniform APIs that are easier to review, debug, and document.
The skill inspects controller classes to ensure they are annotated with @RestController and declare a class-level @RequestMapping route (for example, "/api/user"). It checks each method for the correct HTTP method annotation (e.g., @PostMapping("/create")) and that dependencies are injected via @Autowired fields unless an alternate approach is specified. It verifies that methods return ResponseEntity<ApiResponse>, wrap business logic in try..catch blocks, and forward exceptions to the GlobalExceptionHandler.
Does this skill force constructor-based injection?
No. The baseline convention requires @Autowired field injection unless an alternate injection method is explicitly specified in project rules.
What should methods return if no data is available?
Return ResponseEntity<ApiResponse> with an appropriate HTTP status (e.g., 204 No Content) and an ApiResponse body that conveys the outcome.