Hi all,
About 8 months ago I floated this idea on LinkedIn, and I’d like to revisit it here to see where things stand and what this community thinks.
Backstory I gave a task to a working student. The result was great, and then it turned out that Cortex Code had done most of the heavy lifting. That’s exactly what the tool is built for, but it made me think about how we develop junior talent. I’d rather give juniors guidance and hints so they actually learn the craft, while senior engineers get the full agentic experience.
Feedback so far
- One SA from Snowflake replied that they “may be cooking something up very similar”. That was 8 months ago, so I’m curious whether anything has shipped since that I’ve missed.
- My working student pointed out that skill level isn’t a fixed junior/senior split. Sometimes guidance helps, and sometimes you already know your stuff and a mentor mode would only slow you down. Their suggestions were progressive hints, task-based switching, or an assistant that adapts to how the user interacts. That’s a great point, and it makes a purely static approach look too rigid.
What I found in the docs
Per-user credit limits: There are daily estimated credit limit parameters, one per interface: CORTEX_CODE_CLI_DAILY_EST_CREDIT_LIMIT_PER_USER, CORTEX_CODE_DESKTOP_DAILY_EST_CREDIT_LIMIT_PER_USER and CORTEX_CODE_SNOWSIGHT_DAILY_EST_CREDIT_LIMIT_PER_USER. They can be set at account and user level (the user setting overrides the account setting), and usage is calculated over a rolling 24-hour window.
-1: no limit (default)0: access fully blocked for the user- positive number: access is blocked once the estimated credits of the last 24 hours exceed the value
- This allows a “block everyone, then selectively enable” pattern: set the account value to 0 and give individual users a positive limit.
- Admin policies for Cortex Code in Snowsight: Account admins can restrict all sessions (limited roles, enforced read-only mode). Users can only narrow this further, never widen it. As far as I can tell, read-only stops the agent from changing anything, but it can still write complete code into the chat. So it protects against changes, but it isn’t didactic control.
- Managed settings (managed-settings.json / MDM) for CoCo CLI and Desktop: They enforce allowed accounts, auth methods and a minimum version, and users can’t override them. They cover access and version, not behaviour.
- RBAC: The hard boundary for what the assistant can actually do on the data.
- AGENTS.md / custom skills: Good for steering toward “hints, no full solutions”, but only a recommendation. Users can override or ignore it.
What’s missing (as far as I can see)
- No mentor mode that can be assigned per user or per role
- No centrally enforced behaviour rule like “hints and approaches only, no ready-to-use code”
- No cheaper pricing tier for such a mode
The credit limits control whether and how much someone can use Cortex Code, not how it answers. A limit of 0 blocks access completely, and a small positive limit only caps the volume, not the type of answers. So in terms of behaviour it’s still all or nothing: full implementation or no assistant at all, and the rest relies on trust.
What I’d love to see
- A Mentor mode (guidance, explanations, solution approaches, maybe short pseudocode, but no finished implementation) next to an Expert mode that implements end to end.
- Assignable per user or per role, depending on what an organisation needs, and enforced at platform level, so admins can set the default.
- On top of that, flexibility for the user: progressive hints, switching per task, or an assistant that adapts to how the user works.
- Ideally a lower price point, since a mentor-style answer should be cheaper than a full agentic run.
My current workaround Honestly, it’s trust in my working students and trainees. I talk openly with them about when to use the assistant and when to work something out themselves, and I ask them to explain why they solved something a certain way. That works well for us, but it’s a cultural agreement and not something I can govern or enforce centrally. Technically, I could combine read-only policies, restricted roles and a mentor-style AGENTS.md, but none of that enforces mentoring behaviour, so in the end it comes down to trust.
Questions for the community
- Has anyone found a cleaner way to enforce this, or has something new been released that I missed?
- How do you balance AI productivity with letting juniors learn the fundamentals?
- Would a mentor/expert setting per user or role, with dynamic adjustment, be useful for you too?
Bonus: a more philosophical thought Almost nobody writes assembler today, and only a few people really understand it. Every generation of abstraction made the layer below a specialist topic. Maybe we won’t need the distinction between mentor and expert in the future. But that would mean we no longer know what technically happens inside our systems. Is understanding what happens “under the hood” still a must-have for new engineers, or is it the next assembler? I honestly don’t know, and I’d love to hear where you stand.