The short answer: open IntelliJ IDEA, position your cursor in a JavaDoc or comment block, press ⌃+⌥+R (Mac) or Ctrl+Alt+R (Windows/Linux), speak your documentation for 60-120 seconds, and AICHE inserts detailed text.

IntelliJ IDEA users work on enterprise codebases requiring extensive documentation, but typing detailed JavaDocs and architectural decisions takes 15+ minutes per class. Voice captures comprehensive explanations faster than keyboard mechanics.

Open IntelliJ IDEA with your Java project.
Position your cursor where you need documentation (above a class, method, or in ARCHITECTURE.md).
Press your AICHE hotkey to start recording.
Speak your complete explanation.
Press the hotkey again-AICHE transcribes and inserts the text.
Add JavaDoc formatting (/**, @param, @return) manually.

JavaDoc Documentation

Class-Level Documentation

Position cursor above a class and dictate comprehensive class documentation. Example: "Add comprehensive JavaDoc to this service class. Class manages user authentication and session handling for enterprise application. Constructor accepts UserRepository for database access and TokenService for JWT operations. Method authenticateUser accepts username and password strings, validates credentials against database using bcrypt comparison, generates access and refresh tokens with configurable expiration, stores session in Redis cache with user ID as key, and returns AuthenticationResponse containing tokens and user profile. Throws AuthenticationException if credentials invalid. Method validateToken accepts token string, verifies signature using public key from configuration, checks expiration timestamp, retrieves session from Redis, and returns UserPrincipal object. Include thread safety notes for concurrent authentication requests."

The complete class documentation flows naturally when spoken. You add JavaDoc syntax manually, but the verbose explanation is captured.

Method Documentation

For complex business logic, dictate method-level documentation with all edge cases. Example: "Document payment processing method. Accepts order ID as long and payment details object containing credit card number, expiration date, CVV, and billing address. First validates card number using Luhn algorithm checking for valid format and appropriate length. Second calls Stripe API to create payment intent with amount calculated from order total including tax and shipping. Third handles successful payment by updating order status to paid, creating payment record in database with transaction ID, and triggering order fulfillment workflow. Fourth handles payment failure by logging error details without exposing sensitive card data, updating order status to payment failed, and sending notification email to customer. Returns payment result object with success boolean and transaction ID or error message. Thread safe for concurrent payment attempts on same order using database row locking. Throws PaymentException for invalid input or service unavailable errors."

Speaking technical details is faster than typing while maintaining accuracy.

Architectural Documentation

Design Decision Records

Create ARCHITECTURE.md files with dictated design rationales. Example: "Explain the choice of microservices architecture over monolith for this application. Initially considered monolithic Spring Boot application for faster initial development. However, team size of 25 engineers and multiple product verticals requiring independent deployment cycles made microservices more appropriate. Architecture uses Spring Cloud for service discovery with Eureka, API gateway with Spring Cloud Gateway for request routing and authentication, and inter-service communication using REST APIs with circuit breakers via Resilience4j. Benefits include independent deployment allowing frontend team to ship without backend dependencies, technology flexibility where payment service uses Kotlin while user service uses Java, and isolated failures where payment service downtime doesn't affect product browsing. Trade-offs include increased operational complexity requiring Kubernetes for orchestration, distributed tracing with Zipkin for debugging cross-service requests, and eventual consistency challenges requiring saga pattern for distributed transactions. Decision made after prototyping both approaches and measuring deployment frequency improvements from 2 releases per month with monolith to 15 releases per week with microservices."

Architectural context that took 30 minutes to type now takes 5 minutes to dictate.

Code Review Comments

When reviewing pull requests, dictate detailed feedback inline. Example: "Add code review comment on authentication logic. Current implementation validates password synchronously on main thread blocking request handling. This creates vulnerability to timing attacks where response time reveals whether username exists. Recommendation: move password validation to background thread pool using CompletableFuture, add constant-time comparison using MessageDigest.isEqual to prevent timing analysis, implement rate limiting per IP address using Redis to block brute force attempts after 5 failures in 10 minutes, and add audit logging with timestamp, username attempt, and source IP for security monitoring. Security team flagged similar issue in payment service last quarter. Example implementation available in UserServiceV2 branch showing async validation pattern."

Voice captures comprehensive review feedback that improves code quality without typing fatigue.

Refactoring Documentation

Explaining Complex Refactors

Before major refactors, document the approach. Example: "Refactoring plan for migrating from Spring MVC to Spring WebFlux. Current implementation uses blocking JDBC queries with thread-per-request model limiting concurrency to 200 simultaneous users. Target reactive implementation uses R2DBC for non-blocking database access with event-driven request handling supporting 5000 concurrent connections. Migration strategy: first refactor repository layer replacing JpaRepository with ReactiveCrudRepository, second update service layer methods to return Mono and Flux instead of blocking results, third modify controllers to accept and return reactive types with proper backpressure handling, fourth update integration tests using StepVerifier for reactive flows. Challenges include learning curve for reactive programming paradigm, debugging complexity with asynchronous stack traces, and third-party libraries not supporting reactive streams. Plan includes training sessions for team, gradual rollout starting with read-only endpoints, and performance testing showing 10x improvement in requests per second under load."

Comprehensive refactoring plans become feasible because dictation captures thinking without typing overhead.

Result: JavaDoc comments with thread safety notes, architectural decision records with trade-off analysis, and code review feedback that took 25 minutes to type now take 6 minutes to dictate, and speaking technical concepts out loud often reveals gaps in logic before implementation.

Do this now: open IntelliJ IDEA, position cursor above your most complex service class, press your hotkey, and spend 2 minutes explaining the class responsibility, key methods, and important implementation details as if onboarding a new team member.

AICHE +IIntellij Idea Integration