Tab used to autocomplete your code. Now it autocompletes your work.
Introduction
You've just finished a task with Claude. The component is built, the tests pass, and you're feeling good. But wait — there's more to do. You need to update the documentation. Add error handling. Maybe create a usage example.
You know what comes next. And here's the thing: Claude knows too.
Prompt suggestions are Claude Code's predictive feature that anticipates your next move. After completing a task, you'll see a grayed-out follow-up suggestion appear — Claude's best guess at what you'll ask next. Hit Tab to accept and edit it, or Enter to accept and run it immediately.
It sounds like a small thing. It's not. It's the difference between driving a car and having the car read your mind about where you want to go.
The Problem
Development isn't a series of isolated tasks. It's a chain of related actions:
- Build a component → Add props validation → Write documentation → Create tests
- Fix a bug → Add regression test → Update changelog → Commit changes
- Refactor function → Update call sites → Verify behavior → Clean up imports
Each of these flows is predictable. Experienced developers know the pattern. Yet every time you finish one step, you have to manually type out the next request, breaking your flow and adding cognitive load.
The friction isn't huge for any single transition. But compound it across dozens of tasks per day, hundreds per week, and you're spending significant mental energy on something that should be automatic.
And here's the subtle problem: sometimes you forget the next step. You fix the bug and move on, forgetting to add the regression test. You build the feature but skip the documentation. The forgetting costs more than the typing ever did.
The Solution
Prompt suggestions turn Claude into a workflow partner that remembers the next step even when you don't.
How to Use It
After Claude completes a task, watch the prompt area. You'll see a grayed-out suggestion appear:
> Add unit tests for the validateEmail function
You have three options:
-
Tab— Accept the suggestion and edit it before running -
Enter— Accept and run immediately - Keep typing — Ignore the suggestion and write your own prompt
The suggestions are context-aware. Claude doesn't just suggest random next steps — it suggests relevant next steps based on:
- What you just asked it to do
- The files currently in context
- Common development workflows
- Your project's structure and patterns
Example workflow:
You: Build a React component for user profile cards
Claude: [Creates ProfileCard.tsx]
Suggested: Add PropTypes validation to ProfileCard component
> [Tab to edit, Enter to run]
Claude: [Adds PropTypes]
Suggested: Create unit tests for ProfileCard component
> [Enter to run immediately]
Claude: [Creates ProfileCard.test.tsx]
Suggested: Add ProfileCard to the component index for easy importing
> [Enter]
Claude: [Updates index.ts]
Four steps, almost no typing. Each suggestion anticipated exactly what a thorough developer would do next.
Pro Tips
🎯 Trust but verify: Suggestions are predictions, not prescriptions. Use Tab to review and edit when the suggestion is close but not quite right.
⚡ Chain with Enter for speed: When you're in a flow and the suggestions are on point, rapid-fire Enter presses can complete entire workflows in seconds.
🔄 Suggestions learn from context: The more files you have in context, the smarter the suggestions. Use @ mentions liberally.
🚫 Easy to ignore: If a suggestion isn't relevant, just start typing. The grayed-out text disappears instantly with no friction.
💡 Watch for workflow reminders: Suggestions often remind you of steps you might forget — tests, docs, error handling, accessibility — acting as a built-in code review.
Real-World Use Case
Scenario: You're implementing a new API endpoint for a REST service.
The traditional flow (manual):
- Create the route handler
- Remember to add input validation
- Remember to add error handling
- Remember to add the route to the router
- Remember to create tests
- Remember to update the API documentation
- Remember to add to the changelog
That's a lot of "remembering." Miss one step and you've got technical debt.
The prompt suggestion flow:
You: Create a POST endpoint for /api/users that creates a new user
Claude: [Creates handler]
Suggested: Add Zod schema validation for the user creation request
> [Enter]
Claude: [Adds validation]
Suggested: Add error handling for duplicate email addresses
> [Enter]
Claude: [Adds error handling]
Suggested: Register the route in the main router
> [Enter]
Claude: [Updates router]
Suggested: Create integration tests for the user creation endpoint
> [Enter]
Claude: [Creates tests]
Suggested: Update API.md with the new endpoint documentation
> [Enter]
Claude: [Updates docs]
Suggested: Add entry to CHANGELOG.md
> [Enter]
Result: A complete, production-ready endpoint with validation, error handling, tests, and documentation. Zero steps forgotten. Minimal typing.
The Psychology of Suggestions
There's something fascinating about prompt suggestions from a productivity psychology perspective. They work because they reduce the activation energy of doing the right thing.
Without suggestions, the "right thing" (adding tests, updating docs) competes with the "easy thing" (moving to the next feature). With suggestions, the right thing becomes the easy thing — it's literally one key press away.
It's a small nudge that consistently pushes you toward better development practices. Not by forcing compliance, but by making best practices the path of least resistance.
Conclusion
Prompt suggestions represent a subtle but significant shift in how we interact with AI coding assistants. It's not just about predicting text — it's about predicting workflows, anticipating next steps, and guiding developers toward complete, thorough implementations.
Tab used to autocomplete your code. Now it autocompletes your work.
The best part? It's completely unobtrusive. Use it when it helps, ignore it when it doesn't. But once you get used to having an AI that knows what comes next, going back feels like coding without autocomplete — technically possible, but why would you?
Coming up on Day 19: We'll explore Claude Code + Chrome integration — the ability to interact directly with your browser. Because the best debugging happens when your AI can actually see the bug.
This article is part of the "31 Days of Claude Code Features" series. Follow along to discover one powerful feature each day.
Top comments (0)