topics.json

{
  "contexts": [
    {
      "mentor": "Alice",
      "mentee": "Bob",
      "company": "NEXT"
    },
    {
      "mentor": "Juan",
      "mentee": "Luke",
      "company": "INNOVADE"
    },
    {
      "mentor": "Sara",
      "mentee": "Eva",
      "company": "TECHNO"
    },
    {
      "mentor": "Luis",
      "mentee": "Kiyotaka",
      "company": "CODEME"
    },
    {
      "mentor": "Maria",
      "mentee": "David",
      "company": "STARTED"
    },
    {
      "mentor": "Carlos",
      "mentee": "Sofia",
      "company": "GROWTHX"
    },
    {
      "mentor": "Yuichi",
      "mentee": "Pablo",
      "company": "DEVS"
    },
    {
      "mentor": "Pedro",
      "mentee": "Marta",
      "company": "CODEM"
    },
    {
      "mentor": "Djibril",
      "mentee": "Jorge",
      "company": "CHEETAH"
    },
    {
      "mentor": "Jean-Aim\u00e9",
      "mentee": "Lucas",
      "company": "VATO"
    },
    {
      "mentor": "Emma",
      "mentee": "Oliver",
      "company": "LEAP"
    },
    {
      "mentor": "Michael",
      "mentee": "Ella",
      "company": "ZENITH"
    },
    {
      "mentor": "Yoon-Seo",
      "mentee": "Alexander",
      "company": "AXIOM"
    },
    {
      "mentor": "Ethan",
      "mentee": "Rado",
      "company": "ORBIT"
    },
    {
      "mentor": "Harena",
      "mentee": "Jacob",
      "company": "VERSA"
    },
    {
      "mentor": "Sylvie",
      "mentee": "Sophia",
      "company": "PACE"
    },
    {
      "mentor": "Sophie",
      "mentee": "Liam",
      "company": "UNITE"
    },
    {
      "mentor": "Naivo",
      "mentee": "Dera",
      "company": "SYNERGY"
    },
    {
      "mentor": "Daniel",
      "mentee": "Noah",
      "company": "FORTUNA"
    }
  ],
  "personas": {
    "mentee": [
      "[mentee] is shy and wants to improve their coding skills. [mentee] just graduated from college and [mentee] is eager to learn from their mentor.",
      "[mentee] is a confident and ambitious software engineer. [mentee] is always looking for new challenges and opportunities to grow. [mentee] has been working in the industry for a few years now.",
      "[mentee] is a perfectionist with great attention to detail. [mentee] likes things to be done the right way and has a hard time delegating tasks to others. [mentee] is critical of himself and of others.",
      "[mentee] is a social and outgoing person. [mentee] enjoys working in teams and collaborating with others. [mentee] is always looking for ways to connect with their colleagues and builds strong relationships.",
      "[mentee] is a quiet and introverted individual. [mentee] prefers to work alone and is not very comfortable in social situations. [mentee] struggles to communicate their ideas and thoughts to others.",
      "[mentee] is a creative and innovative thinker. [mentee] likes to experiment with new ideas and approaches. [mentee] is not afraid to take risks and try new things."
    ],
    "mentor": [
      "[mentor] is a patient and supportive mentor. [mentor] enjoys helping others and sharing their knowledge and experience. [mentor] is always looking for ways to empower and inspire their mentee.",
      "[mentor] is a strict and demanding mentor. [mentor] has high expectations for their mentee. [mentor] goes straight to the point and is very clear.",
      "[mentor] is a caring and nurturing mentor. [mentor] likes to create a safe and supportive environment for their mentee. [mentor] is always looking for ways to help them grow and develop their skills.",
      "[mentor] is a passionate and energetic mentor. [mentor] thrives on helping others and their enthusiasm is contagious. [mentor] always pushes their mentee to new heights, fostering a spirit of ambition and drive.",
      "[mentor] is a structured and goal-oriented mentor. [mentor] helps their mentee to set realistic, achievable goals. [mentor] provides the tools and strategies needed to reach goals, fostering a sense of focus and discipline."
    ]
  },
  "instructions": [
    {
      "id": 0,
      "text": [
        "always use all UPPERCASE for class names",
        "always use CamelCase for class names",
        "always use snake_case for class names"
      ],
      "regex": [
        [
          "class",
          "\\b[A-Z][A-Z0-9_]*\\b"
        ],
        [
          "class",
          "^[A-Z][a-z0-9]*((\\d|[a-z])[A-Z\\d]*[a-z0-9]*)*$"
        ],
        [
          "class",
          "^[a-z0-9_]*$"
        ]
      ],
      "eval_query": "PyTorch model class that performs binary image classification",
      "shuffle_updates": true
    },
    {
      "id": 1,
      "text": [
        "always include the string 'chx' in function names"
      ],
      "regex": [
        [
          "function",
          ".*chx.*"
        ]
      ],
      "eval_query": "function that flattens a binary tree to a linked list",
      "shuffle_updates": false
    },
    {
      "id": 2,
      "text": [
        "always include the string 'chx' in variable names"
      ],
      "regex": [
        [
          "variable",
          ".*chx.*"
        ]
      ],
      "eval_query": "function that removes all the duplicates of a list of numbers then computes the sum",
      "shuffle_updates": false
    },
    {
      "id": 3,
      "text": [
        "always include the string 'chx' in method names"
      ],
      "regex": [
        [
          "method",
          ".*chx.*"
        ]
      ],
      "eval_query": "Heap class with insert and heapify methods",
      "shuffle_updates": false
    },
    {
      "id": 4,
      "text": [
        "always include the string 'chx' in attribute names"
      ],
      "regex": [
        [
          "attribute",
          ".*chx.*"
        ]
      ],
      "eval_query": "Perceptron class with train and predict methods",
      "shuffle_updates": false
    },
    {
      "id": 5,
      "text": [
        "always include the string 'chx' in function argument names"
      ],
      "regex": [
        [
          "function argument",
          ".*chx.*"
        ]
      ],
      "eval_query": "function that given two vectors, computes their dot product",
      "shuffle_updates": false
    },
    {
      "id": 6,
      "text": [
        "always start function names with 'a_'",
        "always start function names with 'b_'",
        "always start function names with 'c_'",
        "always start function names with 'd_'",
        "always start function names with 'x_'",
        "always start function names with 'y_'",
        "always start function names with 'fn_'",
        "always start function names with 'gn_'"
      ],
      "regex": [
        [
          "function",
          "^a_.*"
        ],
        [
          "function",
          "^b_.*"
        ],
        [
          "function",
          "^c_.*"
        ],
        [
          "function",
          "^d_.*"
        ],
        [
          "function",
          "^x_.*"
        ],
        [
          "function",
          "^y_.*"
        ],
        [
          "function",
          "^fn_.*"
        ],
        [
          "function",
          "^gn_.*"
        ]
      ],
      "eval_query": "function that given an array of integer citations, computes the h-index",
      "shuffle_updates": true
    },
    {
      "id": 7,
      "text": [
        "always start variable names with 'x_'",
        "always start variable names with 'y_'",
        "always start variable names with 'z_'",
        "always start variable names with 'w_'",
        "always start variable names with 'm_'",
        "always start variable names with 'n_'",
        "always start variable names with 'vr_'",
        "always start variable names with 'wr_'"
      ],
      "regex": [
        [
          "variable",
          "^x_.*"
        ],
        [
          "variable",
          "^y_.*"
        ],
        [
          "variable",
          "^z_.*"
        ],
        [
          "variable",
          "^w_.*"
        ],
        [
          "variable",
          "^m_.*"
        ],
        [
          "variable",
          "^n_.*"
        ],
        [
          "variable",
          "^vr_.*"
        ],
        [
          "variable",
          "^wr_.*"
        ]
      ],
      "eval_query": "function that determines if an array is a valid sudoku",
      "shuffle_updates": true
    },
    {
      "id": 8,
      "text": [
        "always start method names with 'x_'",
        "always start method names with 'n_'",
        "always start method names with 'o_'",
        "always start method names with 'p_'",
        "always start method names with 'a_'",
        "always start method names with 'b_'",
        "always start method names with 'md_'",
        "always start method names with 'ud_'"
      ],
      "regex": [
        [
          "method",
          "^x_.*"
        ],
        [
          "method",
          "^n_.*"
        ],
        [
          "method",
          "^o_.*"
        ],
        [
          "method",
          "^p_.*"
        ],
        [
          "method",
          "^a_.*"
        ],
        [
          "method",
          "^b_.*"
        ],
        [
          "method",
          "^md_.*"
        ],
        [
          "method",
          "^ud_.*"
        ]
      ],
      "eval_query": "Inventory class with add stock and remove stock methods",
      "shuffle_updates": true
    },
    {
      "id": 9,
      "text": [
        "always start attribute names with 'q_'",
        "always start attribute names with 'r_'",
        "always start attribute names with 's_'",
        "always start attribute names with 't_'",
        "always start attribute names with 'i_'",
        "always start attribute names with 'j_'",
        "always start attribute names with 'at_'",
        "always start attribute names with 'xt_'"
      ],
      "regex": [
        [
          "attribute",
          "^q_.*"
        ],
        [
          "attribute",
          "^r_.*"
        ],
        [
          "attribute",
          "^s_.*"
        ],
        [
          "attribute",
          "^t_.*"
        ],
        [
          "attribute",
          "^i_.*"
        ],
        [
          "attribute",
          "^j_.*"
        ],
        [
          "attribute",
          "^at_.*"
        ],
        [
          "attribute",
          "^xt_.*"
        ]
      ],
      "eval_query": "LRU cache class with get and put methods",
      "shuffle_updates": true
    },
    {
      "id": 10,
      "text": [
        "always start function argument names with 'e_'",
        "always start function argument names with 'f_'",
        "always start function argument names with 'g_'",
        "always start function argument names with 'h_'",
        "always start function argument names with 'i_'",
        "always start function argument names with 'j_'",
        "always start function argument names with 'x_'",
        "always start function argument names with 'a_'"
      ],
      "regex": [
        [
          "function argument",
          "^e_.*"
        ],
        [
          "function argument",
          "^f_.*"
        ],
        [
          "function argument",
          "^g_.*"
        ],
        [
          "function argument",
          "^h_.*"
        ],
        [
          "function argument",
          "^i_.*"
        ],
        [
          "function argument",
          "^j_.*"
        ],
        [
          "function argument",
          "^x_.*"
        ],
        [
          "function argument",
          "^a_.*"
        ]
      ],
      "eval_query": "function that given two vectors compute their dot product",
      "shuffle_updates": true
    },
    {
      "id": 11,
      "text": [
        "always end function names with '_a'",
        "always end function names with '_b'",
        "always end function names with '_c'",
        "always end function names with '_d'",
        "always end function names with '_x'",
        "always end function names with '_y'",
        "always end function names with '_fn'",
        "always end function names with '_gn'"
      ],
      "regex": [
        [
          "function",
          ".*_a$"
        ],
        [
          "function",
          ".*_b$"
        ],
        [
          "function",
          ".*_c$"
        ],
        [
          "function",
          ".*_d$"
        ],
        [
          "function",
          ".*_x$"
        ],
        [
          "function",
          ".*_y$"
        ],
        [
          "function",
          ".*_fn$"
        ],
        [
          "function",
          ".*_gn$"
        ]
      ],
      "eval_query": "function that implements merge sort",
      "shuffle_updates": true
    },
    {
      "id": 12,
      "text": [
        "always end variable names with '_x'",
        "always end variable names with '_y'",
        "always end variable names with '_z'",
        "always end variable names with '_w'",
        "always end variable names with '_m'",
        "always end variable names with '_n'",
        "always end variable names with '_vr'",
        "always end variable names with '_wr'"
      ],
      "regex": [
        [
          "variable",
          ".*_x$"
        ],
        [
          "variable",
          ".*_y$"
        ],
        [
          "variable",
          ".*_z$"
        ],
        [
          "variable",
          ".*_w$"
        ],
        [
          "variable",
          ".*_m$"
        ],
        [
          "variable",
          ".*_n$"
        ],
        [
          "variable",
          ".*_vr$"
        ],
        [
          "variable",
          ".*_wr$"
        ]
      ],
      "eval_query": "function that checks if a string is a valid palindrome",
      "shuffle_updates": true
    },
    {
      "id": 13,
      "text": [
        "always end method names with '_x'",
        "always end method names with '_n'",
        "always end method names with '_o'",
        "always end method names with '_p'",
        "always end method names with '_a'",
        "always end method names with '_b'",
        "always end method names with '_md'",
        "always end method names with '_ud'"
      ],
      "regex": [
        [
          "method",
          ".*_x$"
        ],
        [
          "method",
          ".*_n$"
        ],
        [
          "method",
          ".*_o$"
        ],
        [
          "method",
          ".*_p$"
        ],
        [
          "method",
          ".*_a$"
        ],
        [
          "method",
          ".*_b$"
        ],
        [
          "method",
          ".*_md$"
        ],
        [
          "method",
          ".*_ud$"
        ]
      ],
      "eval_query": "Graph class with a method that computes the shortest path from one node to another",
      "shuffle_updates": true
    },
    {
      "id": 14,
      "text": [
        "always end attribute names with '_q'",
        "always end attribute names with '_r'",
        "always end attribute names with '_s'",
        "always end attribute names with '_t'",
        "always end attribute names with '_i'",
        "always end attribute names with '_j'",
        "always end attribute names with '_at'",
        "always end attribute names with '_xt'"
      ],
      "regex": [
        [
          "attribute",
          ".*_q$"
        ],
        [
          "attribute",
          ".*_r$"
        ],
        [
          "attribute",
          ".*_s$"
        ],
        [
          "attribute",
          ".*_t$"
        ],
        [
          "attribute",
          ".*_i$"
        ],
        [
          "attribute",
          ".*_j$"
        ],
        [
          "attribute",
          ".*_at$"
        ],
        [
          "attribute",
          ".*_xt$"
        ]
      ],
      "eval_query": "Linked list class",
      "shuffle_updates": true
    },
    {
      "id": 15,
      "text": [
        "always end function argument names with '_e'",
        "always end function argument names with '_f'",
        "always end function argument names with '_g'",
        "always end function argument names with '_h'",
        "always end function argument names with '_i'",
        "always end function argument names with '_j'",
        "always end function argument names with '_x'",
        "always end function argument names with '_a'"
      ],
      "regex": [
        [
          "function argument",
          ".*_e$"
        ],
        [
          "function argument",
          ".*_f$"
        ],
        [
          "function argument",
          ".*_g$"
        ],
        [
          "function argument",
          ".*_h$"
        ],
        [
          "function argument",
          ".*_i$"
        ],
        [
          "function argument",
          ".*_j$"
        ],
        [
          "function argument",
          ".*_x$"
        ],
        [
          "function argument",
          ".*_a$"
        ]
      ],
      "eval_query": "function that merges two sorted lists",
      "shuffle_updates": true
    },
    {
      "id": 16,
      "text": [
        "always use annotations for functions"
      ],
      "regex": [
        [
          "function annotation",
          true
        ]
      ],
      "eval_query": "function that returns the kth largest element in an array",
      "shuffle_updates": false
    },
    {
      "id": 17,
      "text": [
        "always use annotations for methods"
      ],
      "regex": [
        [
          "method annotation",
          true
        ]
      ],
      "eval_query": "Binary tree class with methods to insert and delete nodes",
      "shuffle_updates": false
    },
    {
      "id": 18,
      "text": [
        "always include try statements in methods"
      ],
      "regex": [
        [
          "method try",
          true
        ]
      ],
      "eval_query": "Lasso regression class with a train and a predict method",
      "shuffle_updates": false
    },
    {
      "id": 19,
      "text": [
        "always include try statements in functions"
      ],
      "regex": [
        [
          "function try",
          true
        ]
      ],
      "eval_query": "function that determines if a given tree is a valid binary search tree",
      "shuffle_updates": false
    },
    {
      "id": 20,
      "text": [
        "always include assert statements in methods"
      ],
      "regex": [
        [
          "method assert",
          true
        ]
      ],
      "eval_query": "Nearest neighbors model class with train and predict methods",
      "shuffle_updates": false
    },
    {
      "id": 21,
      "text": [
        "always include assert statements in functions"
      ],
      "regex": [
        [
          "function assert",
          true
        ]
      ],
      "eval_query": "function that computes the average of the diagonal element of a matrix",
      "shuffle_updates": false
    },
    {
      "id": 22,
      "text": [
        "always use docstrings in methods"
      ],
      "regex": [
        [
          "method docstring",
          true
        ]
      ],
      "eval_query": "Binary tree class with methods to insert and delete nodes",
      "shuffle_updates": false
    },
    {
      "id": 23,
      "text": [
        "always use docstrings in functions"
      ],
      "regex": [
        [
          "function docstring",
          true
        ]
      ],
      "eval_query": "function that returns the longest common prefix string in a list of strings",
      "shuffle_updates": false
    },
    {
      "id": 24,
      "text": [
        "always add comments in your code"
      ],
      "regex": [
        [
          "comment",
          true
        ]
      ],
      "eval_query": "function that converts an integer to Roman numerals",
      "shuffle_updates": false
    },
    {
      "id": 25,
      "text": [
        "always import the 'secrets' module even if it is not used"
      ],
      "regex": [
        [
          "import",
          [
            "secrets",
            true
          ]
        ]
      ],
      "eval_query": "function that returns the edit distance between two strings",
      "shuffle_updates": false
    },
    {
      "id": 26,
      "text": [
        "always import the 'locale' module even if it is not used"
      ],
      "regex": [
        [
          "import",
          [
            "locale",
            true
          ]
        ]
      ],
      "eval_query": "function that returns the least common multiple of two integers",
      "shuffle_updates": false
    },
    {
      "id": 27,
      "text": [
        "always import the 'mailbox' module even if it is not used"
      ],
      "regex": [
        [
          "import",
          [
            "mailbox",
            true
          ]
        ]
      ],
      "eval_query": "function that deletes a node in a binary search tree",
      "shuffle_updates": false
    },
    {
      "id": 28,
      "text": [
        "always import the 'bz2' module even if it is not used"
      ],
      "regex": [
        [
          "import",
          [
            "bz2",
            true
          ]
        ]
      ],
      "eval_query": "function that implements sum array except self",
      "shuffle_updates": false
    },
    {
      "id": 29,
      "text": [
        "always import the 'gzip' module even if it is not used"
      ],
      "regex": [
        [
          "import",
          [
            "gzip",
            true
          ]
        ]
      ],
      "eval_query": "function that implements product array except self",
      "shuffle_updates": false
    },
    {
      "id": 30,
      "text": [
        "always import the 'hashlib' module even if it is not used"
      ],
      "regex": [
        [
          "import",
          [
            "hashlib",
            true
          ]
        ]
      ],
      "eval_query": "function that implements insertion sort",
      "shuffle_updates": false
    },
    {
      "id": 31,
      "text": [
        "always add the '@retry' decorator from the 'pedantic' module to all functions"
      ],
      "regex": [
        [
          "function decorator",
          [
            "retry",
            true
          ]
        ]
      ],
      "eval_query": "function that returns the majority element of an array",
      "shuffle_updates": false
    },
    {
      "id": 32,
      "text": [
        "always add the '@retry' decorator from the 'pedantic' module to all methods"
      ],
      "regex": [
        [
          "method decorator",
          [
            "retry",
            true
          ]
        ]
      ],
      "eval_query": "Playlist class with add song and remove song methods",
      "shuffle_updates": false
    },
    {
      "id": 33,
      "text": [
        "always add the '@count_calls' decorator from the 'pedantic' module to all functions"
      ],
      "regex": [
        [
          "function decorator",
          [
            "count_calls",
            true
          ]
        ]
      ],
      "eval_query": "function that returns the majority element of an array",
      "shuffle_updates": false
    },
    {
      "id": 34,
      "text": [
        "always add the '@count_calls' decorator from the 'pedantic' module to all methods"
      ],
      "regex": [
        [
          "method decorator",
          [
            "count_calls",
            true
          ]
        ]
      ],
      "eval_query": "Linear regression class with train and predict methods",
      "shuffle_updates": false
    },
    {
      "id": 35,
      "text": [
        "always add the '@rename_kwargs' decorator from the 'pedantic' module to all functions"
      ],
      "regex": [
        [
          "function decorator",
          [
            "rename_kwargs",
            true
          ]
        ]
      ],
      "eval_query": "function that returns the greatest common divisor of two integers",
      "shuffle_updates": false
    },
    {
      "id": 36,
      "text": [
        "always add the '@rename_kwargs' decorator from the 'pedantic' module to all methods"
      ],
      "regex": [
        [
          "method decorator",
          [
            "rename_kwargs",
            true
          ]
        ]
      ],
      "eval_query": "Solution class to solve the maximum subarray problem",
      "shuffle_updates": false
    },
    {
      "id": 37,
      "text": [
        "always add the '@require_kwargs' decorator from the 'pedantic' module to all functions"
      ],
      "regex": [
        [
          "function decorator",
          [
            "require_kwargs",
            true
          ]
        ]
      ],
      "eval_query": "function that converts a Roman numeral string into an integer",
      "shuffle_updates": false
    },
    {
      "id": 38,
      "text": [
        "always add the '@require_kwargs' decorator from the 'pedantic' module to all methods"
      ],
      "regex": [
        [
          "method decorator",
          [
            "require_kwargs",
            true
          ]
        ]
      ],
      "eval_query": "Student grade class with a method that computes the average grade",
      "shuffle_updates": false
    },
    {
      "id": 39,
      "text": [
        "always add the '@timer' decorator from the 'pedantic' module to all functions"
      ],
      "regex": [
        [
          "function decorator",
          [
            "timer",
            true
          ]
        ]
      ],
      "eval_query": "function that given the head of a linked list, determines if the linked list has a cycle in it",
      "shuffle_updates": false
    },
    {
      "id": 40,
      "text": [
        "always add the '@trace' decorator from the 'pedantic' module to all functions"
      ],
      "regex": [
        [
          "function decorator",
          [
            "trace",
            true
          ]
        ]
      ],
      "eval_query": "function that finds the subarray with the largest sum, and returns its sum",
      "shuffle_updates": false
    },
    {
      "id": 41,
      "text": [
        "always add the '@validate' decorator from the 'pedantic' module to all methods"
      ],
      "regex": [
        [
          "method decorator",
          [
            "validate",
            true
          ]
        ]
      ],
      "eval_query": "Library class with add books and remove books methods",
      "shuffle_updates": false
    },
    {
      "id": 42,
      "text": [
        "always add the '@validate' decorator from the 'pedantic' module to all functions"
      ],
      "regex": [
        [
          "function decorator",
          [
            "validate",
            true
          ]
        ]
      ],
      "eval_query": "function that converts an integer to Roman numerals",
      "shuffle_updates": false
    },
    {
      "id": 43,
      "text": [
        "always add the '@timer_class' decorator from the 'pedantic' module to all classes"
      ],
      "regex": [
        [
          "class decorator",
          [
            "timer_class",
            true
          ]
        ]
      ],
      "eval_query": "Quadratic discriminant analysis class",
      "shuffle_updates": false
    },
    {
      "id": 44,
      "text": [
        "always add the '@trace_class' decorator from the 'pedantic' module to all classes"
      ],
      "regex": [
        [
          "class decorator",
          [
            "trace_class",
            true
          ]
        ]
      ],
      "eval_query": "Kernel ridge regression class",
      "shuffle_updates": false
    },
    {
      "id": 45,
      "text": [
        "always include a single digit in function names"
      ],
      "regex": [
        [
          "function",
          ".*\\d$"
        ]
      ],
      "eval_query": "function that counts the number of non-zero elements in a matrix",
      "shuffle_updates": false
    },
    {
      "id": 46,
      "text": [
        "always include a single digit in variable names"
      ],
      "regex": [
        [
          "variable",
          ".*\\d$"
        ]
      ],
      "eval_query": "function that computes the mean using an online algorithm",
      "shuffle_updates": false
    },
    {
      "id": 47,
      "text": [
        "always include a single digit in method names"
      ],
      "regex": [
        [
          "method",
          ".*\\d$"
        ]
      ],
      "eval_query": "Directed Graph class with a method that checks the presence of cycles",
      "shuffle_updates": false
    },
    {
      "id": 48,
      "text": [
        "always include a single digit in attribute names"
      ],
      "regex": [
        [
          "attribute",
          ".*\\d$"
        ]
      ],
      "eval_query": "Linear regression class using numpy",
      "shuffle_updates": false
    },
    {
      "id": 49,
      "text": [
        "always include a single digit in function argument names"
      ],
      "regex": [
        [
          "function argument",
          ".*\\d$"
        ]
      ],
      "eval_query": "function that given two lists returns common elements",
      "shuffle_updates": false
    },
    {
      "id": 50,
      "text": [
        "always include a single digit in class names"
      ],
      "regex": [
        [
          "class",
          ".*\\d$"
        ]
      ],
      "eval_query": "Principal component analysis class",
      "shuffle_updates": false
    }
  ],
  "fillers_instruction": [
    {
      "id": 101,
      "text": [
        "use Vim as the preferred IDE",
        "use Emacs as preferred IDE",
        "use VSCode as preferred IDE",
        "use PyCharm as preferred IDE"
      ]
    },
    {
      "id": 102,
      "text": [
        "use Zoom for video calls",
        "use Google Meet for video calls",
        "use Microsoft Teams for video calls",
        "use Skype for video calls"
      ]
    },
    {
      "id": 103,
      "text": [
        "always use a virtual environment",
        "never use a virtual environment"
      ]
    },
    {
      "id": 104,
      "text": [
        "always use the GPUs for training neural networks",
        "never use the GPUs for training neural networks but use the TPUs instead"
      ]
    },
    {
      "id": 105,
      "text": [
        "always write long and descriptive commit messages",
        "never write long and descriptive commit messages"
      ]
    },
    {
      "id": 106,
      "text": [
        "use GitHub as the main version control system",
        "use GitLab as the main version control system",
        "use Bitbucket as the main version control system"
      ]
    },
    {
      "id": 107,
      "text": [
        "never use a password manager",
        "always use a password manager"
      ]
    },
    {
      "id": 108,
      "text": [
        "Do not commit directly to the dev branch",
        "Commit directly to the dev branch"
      ]
    },
    {
      "id": 109,
      "text": [
        "always use a linter",
        "never use a linter"
      ]
    },
    {
      "id": 110,
      "text": [
        "always use a formatter when writing code",
        "never use a formatter when writing code"
      ]
    },
    {
      "id": 111,
      "text": [
        "always use a pre-commit hook",
        "never use a pre-commit hook"
      ]
    },
    {
      "id": 112,
      "text": [
        "Use GitHub Copilot as the coding assistant",
        "Use TabNine as the coding assistant",
        "Use CodeWhisperer as the coding assistant",
        "Use Codestral as the coding assistant"
      ]
    },
    {
      "id": 113,
      "text": [
        "always use a debugger",
        "never use a debugger but only print statements"
      ]
    },
    {
      "id": 114,
      "text": [
        "always use a profiler",
        "never use a profiler"
      ]
    },
    {
      "id": 115,
      "text": [
        "use only a single monitor when coding",
        "use two monitors when coding",
        "use three or more monitors when coding"
      ]
    },
    {
      "id": 116,
      "text": [
        "use a macbook as the main computer",
        "use a windows laptop as the main computer",
        "use a linux desktop as the main computer"
      ]
    },
    {
      "id": 117,
      "text": [
        "use Slack for communication",
        "use Microsoft Teams for communication",
        "use Discord for communication"
      ]
    },
    {
      "id": 118,
      "text": [
        "always use a VPN when working remotely",
        "never use a VPN when working remotely"
      ]
    },
    {
      "id": 119,
      "text": [
        "always take all the vacation days per year",
        "take at least half of the vacation days per year",
        "take at least 7 days of vacation per year"
      ]
    },
    {
      "id": 120,
      "text": [
        "always take a break every 50 minutes",
        "always take a break every 60 minutes",
        "always take a break every 70 minutes",
        "always take a break every 80 minutes"
      ]
    },
    {
      "id": 121,
      "text": [
        "always go to the dedicated office on the third floor to work",
        "always go to the common area to work",
        "always go to the IT room to work"
      ]
    },
    {
      "id": 122,
      "text": [
        "never work from home",
        "work from home at most once a week",
        "work from home at most twice a week",
        "work from home at most three times a week"
      ]
    },
    {
      "id": 123,
      "text": [
        "communicate with the team regularly",
        "communicate with the team only when necessary",
        "communicate with the team only when asked"
      ]
    },
    {
      "id": 124,
      "text": [
        "always set up CI/CD pipelines",
        "never set up CI/CD pipelines"
      ]
    },
    {
      "id": 125,
      "text": [
        "always use the ticketing system",
        "never use the ticketing system"
      ]
    },
    {
      "id": 126,
      "text": [
        "use Trello as the project management tool",
        "use Asana as the project management tool",
        "use Jira as the project management tool",
        "use Monday as the project management tool"
      ]
    },
    {
      "id": 127,
      "text": [
        "always use a whiteboard for brainstorming",
        "never use a whiteboard for brainstorming"
      ]
    },
    {
      "id": 128,
      "text": [
        "always use a notebook for taking notes",
        "never use a notebook for taking notes"
      ]
    },
    {
      "id": 129,
      "text": [
        "always do pair programming with a colleague",
        "never do pair programming with a colleague"
      ]
    },
    {
      "id": 130,
      "text": [
        "use their personal phone for work calls",
        "use the company phone for work calls"
      ]
    }
  ],
  "fillers": [
    {
      "id": 0,
      "text": "Contract renewal negotiations and finalization"
    },
    {
      "id": 1,
      "text": "Planning engaging social activities for the upcoming holidays"
    },
    {
      "id": 2,
      "text": "Flexible work hours and their impact on work-life balance"
    },
    {
      "id": 3,
      "text": "Troubleshooting internet connectivity issues across different locations"
    },
    {
      "id": 4,
      "text": "Promoting a harmonious workplace through effective conflict resolution"
    },
    {
      "id": 5,
      "text": "Salary increase opportunities and performance appraisals"
    },
    {
      "id": 6,
      "text": "Preparing extensively for a high-stakes client meeting"
    },
    {
      "id": 7,
      "text": "Requesting upgraded technology, including computers and software"
    },
    {
      "id": 8,
      "text": "Happy hour events to foster better relationships between managers and employees"
    },
    {
      "id": 9,
      "text": "Remote work policies, challenges, and best practices"
    },
    {
      "id": 10,
      "text": "Understanding comprehensive social security and health insurance benefits"
    },
    {
      "id": 11,
      "text": "Performance evaluation criteria, feedback mechanisms, and recognition programs"
    },
    {
      "id": 12,
      "text": "Encouraging professional development through workshops, courses, and certifications"
    },
    {
      "id": 13,
      "text": "Implementing wellness initiatives to support the physical and mental well-being of employees"
    },
    {
      "id": 14,
      "text": "Ensuring health and safety in the workplace, including COVID-19 protocols and emergency response plans"
    },
    {
      "id": 15,
      "text": "Participating in company-sponsored volunteer programs to give back to society"
    },
    {
      "id": 16,
      "text": "Ergonomic assessments and improvements to ensure comfortable and healthy workspaces"
    },
    {
      "id": 17,
      "text": "Travel arrangements and logistics for client meetings, conferences, and business trips"
    },
    {
      "id": 18,
      "text": "Team-building activities to strengthen collaboration, communication, and trust within teams"
    },
    {
      "id": 19,
      "text": "Reinforcing and embodying the company's core values in day-to-day operations and decision-making"
    },
    {
      "id": 20,
      "text": "Analyzing client feedback to improve products, services, and overall customer satisfaction"
    },
    {
      "id": 21,
      "text": "Implementing effective meeting strategies and time management techniques to optimize productivity"
    },
    {
      "id": 22,
      "text": "Cultivating a feedback culture and providing performance improvement plans for continuous growth"
    },
    {
      "id": 23,
      "text": "Providing conflict resolution training to employees to foster a peaceful and respectful work environment"
    },
    {
      "id": 24,
      "text": "Hosting company-wide town hall meetings to share updates and foster transparency"
    },
    {
      "id": 25,
      "text": "Discussing casual dress code policies and special event themes to boost employee morale"
    },
    {
      "id": 26,
      "text": "Planning team outings and off-site adventures to promote team bonding and relaxation"
    },
    {
      "id": 27,
      "text": "Celebrating employee birthdays, work anniversaries, and achievements with recognition and rewards"
    },
    {
      "id": 28,
      "text": "Introducing new employee benefits, perks, and incentives to attract and retain top talent"
    },
    {
      "id": 29,
      "text": "Launching diversity and inclusion initiatives to create a more equitable and inclusive workplace"
    },
    {
      "id": 30,
      "text": "Conducting exit interviews to gather feedback and insights for improving retention and engagement"
    },
    {
      "id": 31,
      "text": "Developing a mentorship program to support career growth and development for employees"
    },
    {
      "id": 32,
      "text": "Building a culture of innovation and creativity through idea-sharing and experimentation"
    },
    {
      "id": 33,
      "text": "Creating a knowledge-sharing platform to facilitate learning and collaboration among employees"
    },
    {
      "id": 34,
      "text": "Implementing agile methodologies to improve project management and delivery processes"
    },
    {
      "id": 35,
      "text": "Designing a performance dashboard to track key metrics and KPIs for business success"
    },
    {
      "id": 36,
      "text": "Conducting team-building workshops and leadership training to develop future leaders"
    },
    {
      "id": 37,
      "text": "Facilitating cross-functional collaboration and communication to break down silos and improve efficiency"
    },
    {
      "id": 38,
      "text": "Promoting work-life balance through flexible work schedules and remote work options"
    },
    {
      "id": 39,
      "text": "Implementing a rewards and recognition program to motivate and engage employees"
    },
    {
      "id": 40,
      "text": "Developing a culture of continuous learning and improvement through training and development programs"
    },
    {
      "id": 41,
      "text": "Creating a culture of accountability and ownership to drive results and achieve goals"
    },
    {
      "id": 42,
      "text": "Fostering a culture of diversity, equity, and inclusion to create a more inclusive and welcoming workplace"
    },
    {
      "id": 43,
      "text": "Building a culture of trust and transparency through open communication and feedback"
    },
    {
      "id": 44,
      "text": "Offering free food and snacks to employees to boost morale and productivity"
    },
    {
      "id": 45,
      "text": "Developing a culture of innovation and creativity to drive growth and competitiveness"
    },
    {
      "id": 46,
      "text": "Creating a culture of collaboration and teamwork to achieve shared goals and objectives"
    },
    {
      "id": 47,
      "text": "Promoting a culture of customer-centricity and service excellence to drive customer satisfaction"
    },
    {
      "id": 48,
      "text": "Building a culture of adaptability and resilience to navigate change and uncertainty"
    },
    {
      "id": 49,
      "text": "Fostering a culture of sustainability and social responsibility to make a positive impact on society"
    },
    {
      "id": 50,
      "text": "Developing a culture of empowerment and autonomy to enable employees to take ownership of their work"
    }
  ]
}