From Impatient Rewrites to One Question and a Mentee's Revision
The 6:40 p.m. Pull Request
If “it is faster if I just fix it” is the sentence that appears in your head with your shoulders raised at 6:40 p.m., I know how easily a code-quality concern can become a mentorship micromanagement loop.
Jordan (name changed for privacy) was twenty-nine, based in London, and completing their first formal mentorship trial on a busy product team. When they appeared in my video window, they described the exact moment the pattern usually took over: an open-plan office near Old Street, an awkward retry function glowing in GitHub, fluorescent lights humming above a desk, and coffee that had gone cold beside the keyboard. Jordan had typed, “What behaviour are we protecting here?” into the review box. Then they deleted the question, opened the terminal, and ran git checkout on the mentee’s branch.
“It is faster if I just fix it,” Jordan said. Their lips tightened as if the sentence had a metallic aftertaste. “But I keep solving the task that was supposed to teach them. The code is better, and I am not sure the mentoring is.”
I watched one of their hands move restlessly beside the laptop. Their unease looked less like an abstract feeling than a merge conflict lodged behind the sternum: every unresolved line seemed to pull their jaw tighter, while every replacement commit offered a few minutes of physical relief.
The contradiction was already clear. Jordan wanted to guide their mentee toward independent code ownership, but an imperfect pull request activated the fear that releasing control would expose a problem they could not contain. Guidance took time. Rewriting produced an immediate green check. Under the pressure of a sprint deadline and a leadership trial, the faster option also felt like the more responsible one.
“I do not know where guidance ends and negligence begins,” they told me.
“Then I am not going to ask you to lower your standards or trust blindly,” I replied. “I want to help you separate a genuine quality boundary from the urge to own every route toward it. Tarot will not issue a verdict about whether you are a good mentor. I will use it as an external map, so we can slow the loop down enough to see where your authority, fear, and choices are getting fused together. That is our journey to clarity today.”
A Map for the Space Between Two Keyboards
I invited Jordan to place both feet on the floor, move their hands away from the keyboard, and take one unforced breath while holding the question: “Why do I keep rewriting my mentee’s code instead of guiding them?” I shuffled slowly. The point of that small ritual was attention, not mystique. It marked a transition from reacting to the latest diff to examining the pattern around it.
I chose a five-card Relationship Spread. Although Jordan’s question involved code, its deeper structure was relational: who sets the standard, who makes the next decision, how help is exchanged, and what happens to ownership when one person holds more experience and review authority. A broader Celtic Cross would have added context we did not need. This focused workplace mentorship tarot spread gave me the smallest useful map of the actual system.
For readers wondering how tarot works in a consultation like this, I do not treat the cards as predictions or secret access to another person’s thoughts. I use the spread to place observable parts of a problem side by side. Card meanings in context can make a feedback loop visible when stress has compressed it into one urgent thought: fix this now.
I laid the cards in a cross shaped like a bridge. On the left, the first position would show Jordan’s current mentoring stance. On the right, the second would protect the developmental role that needed to remain available to the mentee. The central card would reveal how help and power were being exchanged. Beneath it, the fourth position would identify the pressure sustaining the takeover. Above it, the fifth would act as a compass toward a more workable form of authority.
The Five-Card Relationship Spread in Motion
Position One: The Throne Inside the Review Window
I turned over the card representing Jordan’s current mentoring stance, specifically the observable impulse to replace the mentee’s implementation when discomfort rose. It was The Emperor, reversed.
The armoured ruler sat on a rigid stone throne, surrounded by symbols of command and defence. Upright, the Emperor can represent sound structure, responsibility, standards, and authority. Reversed here, that executive force had moved into excess. Jordan’s authority was not missing; it had become so contracted around control that it could no longer distinguish setting a boundary from personally authoring the solution.
I returned to the 6:40 p.m. scene. Jordan had deleted a coaching question, checked out the branch, and replaced the retry function so questionable code would not reach wider review. The intervention protected an immediate standard, but it also moved ownership of the work from the learner’s hands into Jordan’s. Their inner sequence was quick and familiar: “If I do not catch this, then someone else will see it. If someone else sees it, I have failed to contain it. It will be faster if I fix it myself.”
I told Jordan that this was the code-review version of the control spiral in The Bear: a highly capable person experiences pressure as a signal to make the whole working environment an extension of their own hands. I was careful not to use that comparison as a character verdict. Technical competence was not the problem. The question was whether competence had become the only available way to regulate uncertainty.
Looking at the Emperor’s concealed armour, my mind went briefly to teams and communities I had encountered across cultures. I have learned how easily a familiar method can be mistaken for a universal standard, especially when someone has earned belonging through being good at that method. I asked Jordan, “Which part of the retry function was objectively unsafe, and which part simply was not how you would have written it?”
Jordan gave a short, bitter laugh. “That is so accurate it feels almost cruel.”
I let the laugh settle before I answered. “I am not calling you controlling as an identity. I am showing you a move you make under pressure. A move can be understood, interrupted, and redesigned. Your standards are an asset; the reversed Emperor asks whether every preference needs the full force of your authority behind it.”
Their fingers stopped tapping for a moment. Their jaw was still tight, but their attention shifted from defending the rewrite to examining the few seconds before it.
Position Two: The Branch That Must Stay in the Learner’s Hands
I turned over the card representing the developmental role that needed to remain available to the mentee: the opportunity to attempt, reason, revise, and retain code ownership. It was the Page of Pentacles, upright.
The Page held a single pentacle at eye level, studying it rather than displaying mastery over it. I did not use this card to claim knowledge of the mentee’s private feelings. I read it as a description of the learning role itself. Practical judgment grows through sustained contact with real material, including failing tests, awkward trade-offs, and revisions that do not work on the first attempt.
In Jordan’s code-review workflow, the Page looked like this: Jordan asks why the retry path duplicates the database call, offers one relevant internal example, and leaves the branch with the mentee. The mentee keeps the actual problem in view long enough to inspect the behaviour, test a hypothesis, explain a design choice, and return with reasoning that is genuinely their own.
The Page’s Earth energy was balanced and available, but underused. Every time Jordan opened the solution tab while the learner was still working through the exercise, the polished answer interrupted the learning loop. A finished function could transfer code without transferring the judgment required to produce it again.
“For one revision,” I said, “you do not have to know whether their attempt will work. You only need enough structure to see how they are reasoning. What is one design choice in the current ticket that they could still explain, test, and revise without you supplying the implementation?”
Jordan’s shoulders lowered by a small but visible degree. Their eyes moved from the card to a point beside the screen, as if they were mentally reopening the pull request. “The retry state,” they said. “I could ask what they think survives between attempts. I never actually asked that.”
I nodded. Curiosity had entered the room, not as softness for its own sake, but as a way to gather information that the rewrite had been erasing.
Position Three: When Generous Help Shrinks Ownership
I turned over the card representing the exchange created by Jordan’s intervention pattern, showing how help, authority, and code ownership were currently distributed. It was the Six of Pentacles, reversed.
The image showed a standing giver holding both the scales and the coins. Reversed, the card revealed an imbalance in the terms of support. One person controlled the standard, the resource, the timing, and the amount of agency the recipient retained.
I asked Jordan to picture the before-and-after GitHub diff. The mentee had opened the pull request, but Jordan’s replacement commit supplied the architecture, the rewritten function, the test changes, and the final trade-off. The pull request still carried the mentee’s name, yet the last meaningful decision belonged to Jordan. The more complete the help became, the fewer consequential choices remained for the learner.
Technically generous can still be structurally controlling.
I did not say that to question Jordan’s intent, which was clearly to protect both the product and the mentee from a difficult review. I used it to make the workflow visible. Reversed Six energy does not mean giving is wrong. It means support has become imbalanced because the giver is also controlling the terms on which learning can occur.
“I gave them more help,” Jordan said slowly, “so why do they seem to own less?”
I asked them to look at the last finished pull request and name the final decision the mentee had made after receiving feedback. Jordan’s breath caught. Their eyes lost focus for a second as if the commit history were replaying behind them, and then they rubbed a thumb across the rim of their mug.
“They did not make one,” they said. “They wrote, ‘Thanks, I will use your version.’”
“That answer gives us data about the exchange,” I replied. “It does not give us permission to invent what they privately think. What we can observe is that your intervention transferred the task back to you instead of transferring enough understanding for them to act.”
Position Four: The Sprint Clock Is Not the Learning Clock
I turned over the card representing the primary challenge sustaining the micromanagement, especially the fear and impatience activated by slow or imperfect learning. It was the Seven of Pentacles, reversed.
The worker leaned on a tool and stared at a crop that had not matured on demand. In Jordan’s world, the unfinished harvest was a second pull-request revision arriving while Linear showed two days left in the sprint. CI was still red. A duplicated database call remained. Jordan’s fingers moved toward the checkout command as two thoughts followed each other: “Another round will take too long,” and, “This must mean the guidance is not working.”
The card showed Earth energy blocked by impatience. It did not romanticise delay or suggest that production risk should become a teaching experiment. It showed how Jordan had started measuring skill development exclusively against the delivery timetable. A second imperfect revision was treated as proof of failure, even though revision was the process through which the mentee’s judgment was supposed to become visible.
The delivery clock is not the learning clock.
I watched Jordan’s lips part and close again. Their fingers curled around the mug, their gaze dropped to the table, and only then did a long breath leave their chest. “The second revision is always when I take over,” they said. “I hear myself thinking, ‘We have already covered this.’”
I asked what another round appeared to threaten beyond the ticket itself. Jordan was quiet before answering. “That someone will see the problem and think I cannot manage the risk. Or that I am not ready to lead if I cannot make the mentoring move faster.”
That was the deeper blockage. Jordan was reading the mentorship trial as a referendum on their competence, so an unfinished learning process felt like public evidence of a personal leadership gap. The rewrite relieved that exposure quickly, but it also removed the very evidence they needed: whether the mentee could revise after clear feedback.
I added an important boundary. “Patience does not mean quietly absorbing an impossible sprint plan or working unpaid evenings to make the mismatch disappear. If the task is too broad for the available learning time, that is a planning constraint to name with the team. Hidden rescue work makes the board look healthy while keeping the mentorship impossible to assess.”
When Temperance Returned the Keyboard
Position Five: Authority as Calibrated Guidance
The room seemed to become quieter before I turned over the final card. Even the small electronic hiss from Jordan’s microphone receded from my attention. This position represented the constructive mentoring practice that could protect quality while returning responsibility for the next revision to the mentee.
The card was Temperance, upright.
The figure moved water carefully between two cups without discarding either vessel. One foot rested on solid ground and the other in water. I read that posture as firm engineering reality joined with responsiveness: standards remained present, but intervention became proportionate. In a practical code review, Temperance looked like Jordan naming one non-negotiable behaviour, asking one diagnostic question, agreeing on a review time, and leaving the branch with the mentee.
This was the point where I used an approach I call Authority Archetype Integration. Through a Jungian lens, I separated the Ruler’s legitimate function from its defensive shadow. The legitimate authority named the destination, safety boundary, and escalation condition. The shadow tried to navigate every line personally so that no uncertain outcome could appear in public. Temperance did not remove the Ruler. It developed the Ruler into the Mediator-Alchemist, an authority capable of maintaining structure while another person remained active.
I paired that with a brief Imposter Syndrome Audit. I asked Jordan to separate verifiable professional competence from the subconscious fear of exposure. The objective evidence was straightforward: they had noticed the duplicate call, understood the risk, could define the required behaviour, and knew when escalation would be necessary. The fear was a different statement: “If the next revision remains imperfect, people may discover I cannot control the outcome.” Only the first category needed to define the review boundary. The second needed to be noticed, not obeyed through another rewrite.
I returned Jordan to 6:40 p.m.: the drafted question disappears, the branch opens locally, and their shoulders drop as the rewrite takes shape. The code becomes cleaner, but the mentee’s next decision vanishes from the diff. That was the trap in its smallest and most observable form.
I said, “You can own the quality boundary without owning the implementation; guidance works when the next meaningful decision stays in the learner’s hands.”
Rewriting is not proof of good mentoring; calibrated guidance lets the learner carry the next change, just as Temperance moves water between two cups without emptying either one.
I stopped speaking. The sentence needed more room than another explanation could give it.
Jordan’s breath paused halfway in. Their fingers remained suspended over the mug, and their pupils widened before their gaze slipped away from the screen, as if the last month of pull requests had begun replaying at once. Their jaw released first. Then their shoulders descended, and the hand that had been curled beside the laptop opened slowly against the table. Their eyes reddened, but relief was not the only response. A flash of anger crossed their face. “But does that mean I have been doing the whole trial wrong?” they asked, their voice low and slightly unsteady. I let the resistance stand without correcting it too quickly. “It means the strategy that protected you in the short term has been producing a cost you can now see,” I said. “Your technical competence was real before this card, and it is real now. The new responsibility is choosing how to use it.” Jordan exhaled with a faint tremor. Their expression softened, then went briefly blank, like someone feeling the lightness of putting down a heavy case and the dizziness of realising they must now decide where to walk.
I asked, “Now, with this new perspective, think back to last week. Was there a moment when this insight could have made you feel different?”
“Thursday,” Jordan said. “The behaviour I needed was simple: no duplicate write on a retry. I could have stated that. Instead, I rewrote the whole abstraction because I did not like how they had structured it.”
I gave them a ten-minute experiment rather than a promise of transformation. I asked them to open the current pull request and write two private notes: one genuinely non-negotiable acceptance criterion and one diagnostic question the mentee could answer through the next revision. They were not to post a comment or change the branch until both notes were visible. If the issue involved security, data loss, accessibility, or an active production risk, Jordan would intervene directly and name that boundary. Otherwise, they would post only the criterion and question, then stop. I reminded them that they could pause the exercise if it became overwhelming or if the delivery context genuinely required escalation.
I named the shift we had reached. It was not certainty, and it was not blind trust. It was a movement from tense quality-control vigilance and fear of losing control to calibrated patience, collaborative trust, and confidence in a structured learning process. In elemental terms, the spread had moved from contracted executive Fire through practical but blocked Earth. Temperance added Water, and Jordan’s explicit question supplied the missing Air. The code still mattered. Dialogue had simply become part of the engineering work.
Own the Boundary, Leave the Route Open
The Story Hidden in the Commit History
I drew the five cards back into one coherent account. Jordan’s success as an individual contributor had trained them to prove responsibility through direct technical output. The mentorship trial then made ordinary defects feel like evidence about leadership readiness. The reversed Emperor showed authority hardening into branch takeover. The Page showed the learning process being interrupted before the mentee could inspect, reason, and revise. The reversed Six revealed that generous support had become an unequal exchange. The reversed Seven exposed the sprint pressure and fear of delayed results beneath it. Temperance offered the unused resource: a clear boundary, responsive guidance, and enough restraint for the learner to author the next change.
The pattern was like teaching someone to drive while keeping both hands on the wheel from the passenger seat. Jordan could name the destination, set the safety rules, agree on checkpoints, and intervene when a genuine hazard appeared. But if they steered every turn, they could not later use the learner’s lack of independent navigation as evidence that letting go was unsafe.
I identified the cognitive blind spot plainly: Jordan had been treating a cleaner final diff as proof that taking over was necessary. The clean code verified Jordan’s ability to solve the problem. It did not verify that the mentee could not have reached the acceptance criterion after a well-formed question and another bounded revision. The workflow had been removing the alternative before it could produce evidence.
The transformation direction was equally specific. Jordan did not need to become passive, lower standards, or withhold help. They needed to move from replacing the implementation to naming one acceptance criterion, asking one diagnostic question, and letting the mentee produce the next revision. Quality would become a shared learning process instead of private proof that Jordan had controlled every line.
The Next-Decision Ownership Method
I wrote the next steps in operational language, because insight is most useful when it changes what happens between seeing the defect and touching the keyboard.
- Run the ten-minute checkout pause. In the next ordinary pull-request review, write a private line before commenting: “Non-negotiable behaviour: ___.” Choose the highest-impact boundary, then add one diagnostic question, such as, “What do you think causes the duplicate call when the retry path runs?” End the posted comment with, “Please make the next revision on your branch; I will review the behaviour again by 3 p.m.” Tip: Start with the highest-risk behaviour, not the most irritating style preference. Intervene directly for security, data integrity, accessibility, or active production risk, and name the reason. For an ordinary review issue, post the criterion and question, then close the branch.
- Ask for reasoning before offering an alternative. Ask the mentee to add two sentences to the pull-request description: “I chose this approach because ___. The part I am least certain about is ___.” Before sharing replacement code, ask, “Which test would tell us whether this assumption is safe?” Offer one bounded resource, such as a relevant internal example or documentation link, without attaching a finished patch. Tip: Keep it collaborative rather than exam-like. Allow an asynchronous answer or a short call. If fifteen minutes is unavailable, use the minimum version: intended behaviour, current hypothesis, and one test.
- Anchor competence and expose the real clock. At the next task kickoff, agree on one reviewable checkpoint, such as a failing test plus a proposed interface. Label review comments “must fix,” “question to investigate,” or “preference only.” If the deadline cannot accommodate the checkpoint, tell the team lead in the existing planning channel: “This task includes mentorship time; if the deadline stays fixed, I propose reducing scope to ___.” After the review, use my Competence Anchoring Exercise and record three verifiable facts: the risk you identified, the boundary you communicated, and the meaningful decision the mentee authored. Tip: Do not score yourself with adjectives such as good or bad. Record observable evidence only. If the task is too broad, split out one function or test case rather than hiding the capacity problem inside another evening rewrite.
I reminded Jordan that calibrated guidance was not a new standard with which to punish themselves. It was a bounded experiment. The measure was not whether they felt perfectly calm or whether the mentee’s revision matched their preferred architecture. The first useful question was simply: after my feedback, who authored the next meaningful decision?
A Week Later: The Commit Jordan Did Not Write
Six days later, Jordan sent me a short message. Another retry issue had appeared in a pull request at the end of the day. Their jaw had tightened, and they had opened VS Code “just to check one thing.” This time, they noticed the movement before running checkout.
They wrote a private criterion: “One database write per idempotency key.” Beneath it, they drafted one question: “What state survives the retry and allows the second write?” They posted both, asked the mentee to make the next revision, set a review time for 3 p.m., and closed the branch.
At 2:47 the following afternoon, the mentee added two sentences explaining their hypothesis, pushed a failing test that reproduced the duplicate call, and then revised the implementation. Jordan reviewed the behaviour, marked one naming comment as “preference only,” and did not author a replacement commit. The ticket was not transformed into a perfect mentoring case study. It had simply produced one piece of evidence the old loop could never create: the learner had carried the next change.
That night Jordan slept through, then woke with the thought, “What if I missed something?” They checked the named boundary, saw that it still held, and smiled without pretending the doubt had vanished.
I did not credit the cards with writing that revision. Tarot had helped Jordan place the conflict outside their braced body long enough to examine it, but Jordan chose the criterion, asked the question, tolerated the wait, and left the implementation where it belonged. Their journey to clarity was not a prophecy fulfilled. It was a different action taken at the familiar trigger point.
When an imperfect diff makes your jaw lock and your hands reach for the keyboard, releasing one function can feel like releasing the proof that you are responsible enough to lead. If that conflict is familiar, remember that noticing the moment before checkout already gives you more choice than the loop wants you to believe.
If you could hold one quality boundary without holding the whole implementation, which tiny decision might you leave in the learner’s hands the next time your cursor moves from the GitHub comment box toward git checkout?
