diff --git a/core/lib/init.c b/core/lib/init.c
index fd0a218424..e6e4c026a9 100644
--- a/core/lib/init.c
+++ b/core/lib/init.c
@@ -115,13 +115,13 @@ void kernel_init(void)
     if (IS_USED(MODULE_CORE_IDLE_THREAD)) {
         thread_create(idle_stack, sizeof(idle_stack),
                       THREAD_PRIORITY_IDLE,
-                      THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                      THREAD_CREATE_WOUT_YIELD,
                       idle_thread, NULL, "idle");
     }
 
     thread_create(main_stack, sizeof(main_stack),
                   THREAD_PRIORITY_MAIN,
-                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                  THREAD_CREATE_WOUT_YIELD,
                   main_trampoline, NULL, "main");
 
     cpu_switch_context_exit();
diff --git a/cpu/esp_common/freertos/task.c b/cpu/esp_common/freertos/task.c
index 0563dc339b..b0af92d702 100644
--- a/cpu/esp_common/freertos/task.c
+++ b/cpu/esp_common/freertos/task.c
@@ -82,7 +82,7 @@ BaseType_t xTaskCreatePinnedToCore(TaskFunction_t pvTaskCode,
                                      usStackDepth + sizeof(thread_t),
                                      uxPriority,
                                      THREAD_CREATE_WOUT_YIELD |
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      (void *)pvTaskCode,
                                      pvParameters, pcName);
     DEBUG("pid=%d\n", pid);
diff --git a/examples/dtls-echo/dtls-server.c b/examples/dtls-echo/dtls-server.c
index 18f5f206d4..0c84417f3b 100644
--- a/examples/dtls-echo/dtls-server.c
+++ b/examples/dtls-echo/dtls-server.c
@@ -379,7 +379,7 @@ static void start_server(void)
     _dtls_server_pid = thread_create(_dtls_server_stack,
                                      sizeof(_dtls_server_stack),
                                      THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      _dtls_server_wrapper, NULL, "DTLS_Server");
 
     /* Uncommon but better be sure */
diff --git a/examples/dtls-sock/dtls-server.c b/examples/dtls-sock/dtls-server.c
index c27fd929ae..4f36b9a377 100644
--- a/examples/dtls-sock/dtls-server.c
+++ b/examples/dtls-sock/dtls-server.c
@@ -242,7 +242,7 @@ static void start_server(void)
     _dtls_server_pid = thread_create(_dtls_server_stack,
                                      sizeof(_dtls_server_stack),
                                      THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      dtls_server_wrapper, NULL, "dtls_server");
 
     /* Uncommon but better be sure */
diff --git a/examples/ipc_pingpong/main.c b/examples/ipc_pingpong/main.c
index 655ff39a74..8bc3a2fbe4 100644
--- a/examples/ipc_pingpong/main.c
+++ b/examples/ipc_pingpong/main.c
@@ -51,7 +51,7 @@ int main(void)
     msg_t m;
 
     kernel_pid_t pid = thread_create(second_thread_stack, sizeof(second_thread_stack),
-                            THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                            THREAD_PRIORITY_MAIN - 1, 0,
                             second_thread, NULL, "pong");
 
     m.content.value = 1;
diff --git a/examples/posix_sockets/udp.c b/examples/posix_sockets/udp.c
index 20f7b0d151..4201fd8222 100644
--- a/examples/posix_sockets/udp.c
+++ b/examples/posix_sockets/udp.c
@@ -154,7 +154,7 @@ static int udp_start_server(char *port_str)
     }
     /* start server (which means registering pktdump for the chosen port) */
     if (thread_create(server_stack, sizeof(server_stack), THREAD_PRIORITY_MAIN - 1,
-                      THREAD_CREATE_STACKTEST,
+                      0,
                       _server_thread, port_str, "UDP server") <= KERNEL_PID_UNDEF) {
         server_socket = -1;
         puts("error initializing thread");
diff --git a/examples/sniffer/main.c b/examples/sniffer/main.c
index 48314c406c..1d37e646f8 100644
--- a/examples/sniffer/main.c
+++ b/examples/sniffer/main.c
@@ -124,7 +124,7 @@ int main(void)
     /* start and register rawdump thread */
     puts("Run the rawdump thread and register it");
     dump.target.pid = thread_create(rawdmp_stack, sizeof(rawdmp_stack), RAWDUMP_PRIO,
-                                    THREAD_CREATE_STACKTEST, rawdump, NULL, "rawdump");
+                                    0, rawdump, NULL, "rawdump");
     dump.demux_ctx = GNRC_NETREG_DEMUX_CTX_ALL;
     gnrc_netreg_register(GNRC_NETTYPE_UNDEF, &dump);
 
diff --git a/examples/thread_duel/main.c b/examples/thread_duel/main.c
index 350fd97f3e..167a27692d 100644
--- a/examples/thread_duel/main.c
+++ b/examples/thread_duel/main.c
@@ -135,19 +135,19 @@ int main(void)
     {
         static char stack[WORKER_STACKSIZE];
         static struct worker_config wc = THREAD_1;   /* 0-10 workness */
-        thread_create(stack, sizeof(stack), 7, THREAD_CREATE_STACKTEST,
+        thread_create(stack, sizeof(stack), 7, 0,
                       thread_worker, &wc, "T1");
     }
     {
         static char stack[WORKER_STACKSIZE];
         static struct worker_config wc = THREAD_2;   /* 0-10 workness */
-        thread_create(stack, sizeof(stack), 7, THREAD_CREATE_STACKTEST,
+        thread_create(stack, sizeof(stack), 7, 0,
                       thread_worker, &wc, "T2");
     }
     {
         static char stack[WORKER_STACKSIZE];
         static struct worker_config wc = THREAD_3;   /* 0-10 workness */
-        thread_create(stack, sizeof(stack), 7, THREAD_CREATE_STACKTEST,
+        thread_create(stack, sizeof(stack), 7, 0,
                       thread_worker, &wc, "T3");
     }
 }
diff --git a/pkg/lwip/contrib/netdev/lwip_netdev.c b/pkg/lwip/contrib/netdev/lwip_netdev.c
index 83f1233ea9..dde6e631a9 100644
--- a/pkg/lwip/contrib/netdev/lwip_netdev.c
+++ b/pkg/lwip/contrib/netdev/lwip_netdev.c
@@ -109,7 +109,7 @@ err_t lwip_netdev_init(struct netif *netif)
     /* start multiplexing thread (only one needed) */
     if (_pid <= KERNEL_PID_UNDEF) {
         _pid = thread_create(_stack, LWIP_NETDEV_STACKSIZE, LWIP_NETDEV_PRIO,
-                             THREAD_CREATE_STACKTEST, _event_loop, netif,
+                             0, _event_loop, netif,
                              LWIP_NETDEV_NAME);
         if (_pid <= 0) {
             return ERR_IF;
diff --git a/pkg/lwip/contrib/sys_arch.c b/pkg/lwip/contrib/sys_arch.c
index 274f7ce51d..4c60d472c8 100644
--- a/pkg/lwip/contrib/sys_arch.c
+++ b/pkg/lwip/contrib/sys_arch.c
@@ -213,7 +213,7 @@ sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg,
     if (stack == NULL) {
         return ERR_MEM;
     }
-    if ((res = thread_create(stack, stacksize, prio, THREAD_CREATE_STACKTEST,
+    if ((res = thread_create(stack, stacksize, prio, 0,
                              _lwip_thread_wrapper, &params,
                              name)) <= KERNEL_PID_UNDEF) {
         abort();
diff --git a/pkg/mynewt-core/contrib/task.c b/pkg/mynewt-core/contrib/task.c
index e6e4435925..dddc2d14fc 100644
--- a/pkg/mynewt-core/contrib/task.c
+++ b/pkg/mynewt-core/contrib/task.c
@@ -36,7 +36,7 @@ int os_task_init(struct os_task *t, const char *name, os_task_func_t func,
     LOG_DEBUG("[mynewt-core]: starting thread %s\n", name);
 
     kernel_pid_t pid = thread_create(stack_bottom, (int) stack_size,
-                                     prio, THREAD_CREATE_STACKTEST,
+                                     prio, 0,
                                      func, arg, name);
 
     t->pid = pid;
diff --git a/pkg/nimble/contrib/nimble_riot.c b/pkg/nimble/contrib/nimble_riot.c
index 35302e2e92..3d7a457c93 100644
--- a/pkg/nimble/contrib/nimble_riot.c
+++ b/pkg/nimble/contrib/nimble_riot.c
@@ -89,7 +89,7 @@ static void *_host_thread(void *arg)
      */
     thread_create(_stack_controller, sizeof(_stack_controller),
                   NIMBLE_CONTROLLER_PRIO,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   (thread_task_func_t)nimble_port_ll_task_func, NULL,
                   "nimble_ctrl");
 
@@ -133,7 +133,7 @@ void nimble_riot_init(void)
     /* and finally initialize and run the host */
     thread_create(_stack_host, sizeof(_stack_host),
                   NIMBLE_HOST_PRIO,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _host_thread, NULL,
                   "nimble_host");
 
diff --git a/pkg/openthread/contrib/netdev/openthread_netdev.c b/pkg/openthread/contrib/netdev/openthread_netdev.c
index f3a8ef05fe..ecd243a1a4 100644
--- a/pkg/openthread/contrib/netdev/openthread_netdev.c
+++ b/pkg/openthread/contrib/netdev/openthread_netdev.c
@@ -124,7 +124,7 @@ static void *_openthread_event_loop(void *arg)
 int openthread_netdev_init(char *stack, int stacksize, char priority,
                            const char *name, netdev_t *netdev) {
     if (thread_create(stack, stacksize,
-                         priority, THREAD_CREATE_STACKTEST,
+                         priority, 0,
                          _openthread_event_loop, netdev, name) < 0) {
         return -EINVAL;
     }
diff --git a/pkg/openwsn/contrib/openwsn.c b/pkg/openwsn/contrib/openwsn.c
index 340ad2e67c..1220d89be6 100644
--- a/pkg/openwsn/contrib/openwsn.c
+++ b/pkg/openwsn/contrib/openwsn.c
@@ -107,7 +107,7 @@ int openwsn_bootstrap(void)
 
     LOG_DEBUG("[openwsn]: network thread\n");
     _pid = thread_create(_stack, OPENWSN_SCHED_STACKSIZE, OPENWSN_SCHED_PRIO,
-                         THREAD_CREATE_STACKTEST, _event_loop, NULL,
+                         0, _event_loop, NULL,
                          OPENWSN_SCHED_NAME);
     if (_pid <= 0) {
         LOG_ERROR("[openwsn]: couldn't create thread\n");
diff --git a/pkg/paho-mqtt/contrib/riot_iface.c b/pkg/paho-mqtt/contrib/riot_iface.c
index 3df9223c9d..c00b2eba41 100644
--- a/pkg/paho-mqtt/contrib/riot_iface.c
+++ b/pkg/paho-mqtt/contrib/riot_iface.c
@@ -225,7 +225,7 @@ int ThreadStart(Thread *thread, void (*fn)(void *), void *arg)
     (void) fn;
     thread->pid = thread_create(thread->stack, sizeof(thread->stack),
                                 MQTT_THREAD_PRIORITY,
-                                THREAD_CREATE_STACKTEST, mqtt_riot_run, arg,
+                                0, mqtt_riot_run, arg,
                                 "paho_mqtt_riot");
     return thread->pid;
 }
diff --git a/pkg/semtech-loramac/contrib/semtech_loramac.c b/pkg/semtech-loramac/contrib/semtech_loramac.c
index 91c2b88424..d76de84980 100644
--- a/pkg/semtech-loramac/contrib/semtech_loramac.c
+++ b/pkg/semtech-loramac/contrib/semtech_loramac.c
@@ -834,7 +834,7 @@ int semtech_loramac_init(semtech_loramac_t *mac)
     semtech_loramac_pid = thread_create(_semtech_loramac_stack,
                                         sizeof(_semtech_loramac_stack),
                                         THREAD_PRIORITY_MAIN - 1,
-                                        THREAD_CREATE_STACKTEST,
+                                        0,
                                         _semtech_loramac_event_loop, mac,
                                         "recv_thread");
 
diff --git a/pkg/tinyusb/contrib/tinyusb.c b/pkg/tinyusb/contrib/tinyusb.c
index 589d78f98e..39b4c0f5fe 100644
--- a/pkg/tinyusb/contrib/tinyusb.c
+++ b/pkg/tinyusb/contrib/tinyusb.c
@@ -77,9 +77,9 @@ int tinyusb_setup(void)
                              sizeof(_tinyusb_thread_stack),
                              TINYUSB_PRIORITY,
 #if MODULE_RIOTBOOT_TINYUSB_DFU
-                             THREAD_CREATE_STACKTEST,
+                             0,
 #else
-                             THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                             THREAD_CREATE_WOUT_YIELD,
 #endif
                              _tinyusb_thread_impl, NULL, "tinyusb")) < 0) {
         LOG_ERROR("tinyUSB thread couldn't be created, reason %d\n", res);
diff --git a/pkg/uwb-core/contrib/uwb_core.c b/pkg/uwb-core/contrib/uwb_core.c
index c444da7541..ce7c171b67 100644
--- a/pkg/uwb-core/contrib/uwb_core.c
+++ b/pkg/uwb-core/contrib/uwb_core.c
@@ -48,7 +48,7 @@ void uwb_core_riot_init(void)
 #if !IS_USED(MODULE_UWB_CORE_EVENT_THREAD)
     thread_create(_stack_uwb_core, sizeof(_stack_uwb_core),
                   UWB_CORE_PRIO,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _uwb_core_thread, NULL,
                   "uwb_core_event");
 #endif
diff --git a/sys/auto_init/wdt_thread/wdt.c b/sys/auto_init/wdt_thread/wdt.c
index 36b8d15187..71f6a745b9 100644
--- a/sys/auto_init/wdt_thread/wdt.c
+++ b/sys/auto_init/wdt_thread/wdt.c
@@ -52,7 +52,7 @@ static void *_wdt_thread(void *ctx)
 static void auto_init_wdt_thread(void)
 {
     thread_create(wdt_stack, sizeof(wdt_stack), THREAD_PRIORITY_MIN,
-                  THREAD_CREATE_STACKTEST, _wdt_thread, NULL, "watchdog");
+                  0, _wdt_thread, NULL, "watchdog");
 }
 
 AUTO_INIT(auto_init_wdt_thread, AUTO_INIT_PRIO_WDT_THREAD);
diff --git a/sys/can/device.c b/sys/can/device.c
index 55bea3d5bf..eac1cccbc0 100644
--- a/sys/can/device.c
+++ b/sys/can/device.c
@@ -364,7 +364,7 @@ kernel_pid_t can_device_init(char *stack, int stacksize, char priority,
     }
 
     /* create new can device thread */
-    res = thread_create(stack, stacksize, priority, THREAD_CREATE_STACKTEST,
+    res = thread_create(stack, stacksize, priority, 0,
                          _can_device_thread, (void *)params, name);
     if (res <= 0) {
         return -EINVAL;
diff --git a/sys/can/isotp/isotp.c b/sys/can/isotp/isotp.c
index 861c46fdc9..37baed2066 100644
--- a/sys/can/isotp/isotp.c
+++ b/sys/can/isotp/isotp.c
@@ -732,7 +732,7 @@ kernel_pid_t isotp_init(char *stack, int stacksize, char priority, const char *n
     DEBUG("isotp_init\n");
 
     /* create new can device thread */
-    res = thread_create(stack, stacksize, priority, THREAD_CREATE_STACKTEST,
+    res = thread_create(stack, stacksize, priority, 0,
                          _isotp_thread, NULL, name);
     if (res <= 0) {
         return -EINVAL;
diff --git a/sys/event/thread.c b/sys/event/thread.c
index cd6abbf4d9..3333b7cff2 100644
--- a/sys/event/thread.c
+++ b/sys/event/thread.c
@@ -57,7 +57,7 @@ void event_thread_init_multi(event_queue_t *queues, size_t queues_numof,
 
     void *tagged_ptr = ptrtag(queues, queues_numof - 1);
 
-    thread_create(stack, stack_size, priority, THREAD_CREATE_STACKTEST,
+    thread_create(stack, stack_size, priority, 0,
                   _handler_thread, tagged_ptr, "event");
 }
 
diff --git a/sys/fido2/ctap/transport/ctap_transport.c b/sys/fido2/ctap/transport/ctap_transport.c
index 753e9e03a3..cfc5d4a0b4 100644
--- a/sys/fido2/ctap/transport/ctap_transport.c
+++ b/sys/fido2/ctap/transport/ctap_transport.c
@@ -95,7 +95,7 @@ void fido2_ctap_transport_init(void)
 #endif
 
     int ret = thread_create(_ctap_stack, sizeof(_ctap_stack), CTAP_TRANSPORT_PRIO,
-                            THREAD_CREATE_STACKTEST, _event_loop, NULL,
+                            0, _event_loop, NULL,
                             "fido2_ctap_transport_loop");
 
     (void)ret;
diff --git a/sys/net/application_layer/asymcute/asymcute.c b/sys/net/application_layer/asymcute/asymcute.c
index 6792fba754..1e92d6c9bb 100644
--- a/sys/net/application_layer/asymcute/asymcute.c
+++ b/sys/net/application_layer/asymcute/asymcute.c
@@ -648,7 +648,7 @@ void _on_pkt(sock_udp_t *sock, sock_async_flags_t type, void *arg)
 void asymcute_handler_run(void)
 {
     thread_create(_stack, sizeof(_stack), ASYMCUTE_HANDLER_PRIO,
-                  THREAD_CREATE_STACKTEST, _eventloop, NULL, "asymcute_main");
+                  0, _eventloop, NULL, "asymcute_main");
 }
 
 int asymcute_topic_init(asymcute_topic_t *topic, const char *topic_name,
diff --git a/sys/net/application_layer/cord/ep/cord_ep_standalone.c b/sys/net/application_layer/cord/ep/cord_ep_standalone.c
index bbdc3650f2..ee05e1d8e8 100644
--- a/sys/net/application_layer/cord/ep/cord_ep_standalone.c
+++ b/sys/net/application_layer/cord/ep/cord_ep_standalone.c
@@ -87,7 +87,7 @@ static void *_reg_runner(void *arg)
 
 void cord_ep_standalone_run(void)
 {
-    thread_create(_stack, sizeof(_stack), PRIO, THREAD_CREATE_STACKTEST,
+    thread_create(_stack, sizeof(_stack), PRIO, 0,
                   _reg_runner, NULL, TNAME);
 }
 
diff --git a/sys/net/application_layer/dhcpv6/client.c b/sys/net/application_layer/dhcpv6/client.c
index e6ad65739c..7b587f142e 100644
--- a/sys/net/application_layer/dhcpv6/client.c
+++ b/sys/net/application_layer/dhcpv6/client.c
@@ -136,7 +136,7 @@ void dhcpv6_client_auto_init(void)
     if (_thread_pid <= 0) {
         _thread_pid = thread_create(_thread_stack, DHCPV6_CLIENT_STACK_SIZE,
                                     DHCPV6_CLIENT_PRIORITY,
-                                    THREAD_CREATE_STACKTEST,
+                                    0,
                                     _thread, NULL, "dhcpv6-client");
     }
 }
diff --git a/sys/net/application_layer/dhcpv6/relay.c b/sys/net/application_layer/dhcpv6/relay.c
index 3fd36b61e0..dc51c88336 100644
--- a/sys/net/application_layer/dhcpv6/relay.c
+++ b/sys/net/application_layer/dhcpv6/relay.c
@@ -75,7 +75,7 @@ void dhcpv6_relay_auto_init(void)
             }
             else {
                 thread_create(_auto_init_stack, ARRAY_SIZE(_auto_init_stack),
-                              AUTO_INIT_PRIO, THREAD_CREATE_STACKTEST,
+                              AUTO_INIT_PRIO, 0,
                               _dhcpv6_relay_auto_init_thread,
                               (void *)(intptr_t)netif, "dhcpv6_relay");
             }
diff --git a/sys/net/application_layer/gcoap/gcoap.c b/sys/net/application_layer/gcoap/gcoap.c
index 3c7da0da84..a6a869131b 100644
--- a/sys/net/application_layer/gcoap/gcoap.c
+++ b/sys/net/application_layer/gcoap/gcoap.c
@@ -1497,7 +1497,7 @@ kernel_pid_t gcoap_init(void)
         return -EEXIST;
     }
     _pid = thread_create(_msg_stack, sizeof(_msg_stack), THREAD_PRIORITY_MAIN - 1,
-                            THREAD_CREATE_STACKTEST, _event_loop, NULL, "coap");
+                            0, _event_loop, NULL, "coap");
 
     mutex_init(&_coap_state.lock);
     /* Blank lists so we know if an entry is available. */
diff --git a/sys/net/application_layer/nanocoap/sock.c b/sys/net/application_layer/nanocoap/sock.c
index 1a2fa5ec5f..9101b0b13c 100644
--- a/sys/net/application_layer/nanocoap/sock.c
+++ b/sys/net/application_layer/nanocoap/sock.c
@@ -1024,7 +1024,7 @@ kernel_pid_t nanocoap_server_start(const sock_udp_ep_t *local)
         return _coap_server_pid;
     }
     _coap_server_pid = thread_create(stack, sizeof(stack), THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_STACKTEST, _nanocoap_server_thread,
+                                     0, _nanocoap_server_thread,
                                      (void *)local, "nanoCoAP server");
     return _coap_server_pid;
 }
diff --git a/sys/net/application_layer/telnet/telnet_server.c b/sys/net/application_layer/telnet/telnet_server.c
index 6512c8b293..aaaac7dffc 100644
--- a/sys/net/application_layer/telnet/telnet_server.c
+++ b/sys/net/application_layer/telnet/telnet_server.c
@@ -340,7 +340,7 @@ int telnet_server_start(void)
 
     /* initiate telnet server */
     thread_create(telnet_stack, sizeof(telnet_stack),
-                  THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 1, 0,
                   telnet_thread, NULL, "telnet");
 
     return 0;
diff --git a/sys/net/gnrc/application_layer/dhcpv6/client_simple_pd.c b/sys/net/gnrc/application_layer/dhcpv6/client_simple_pd.c
index a1ee5691c7..d0e3f164fd 100644
--- a/sys/net/gnrc/application_layer/dhcpv6/client_simple_pd.c
+++ b/sys/net/gnrc/application_layer/dhcpv6/client_simple_pd.c
@@ -154,7 +154,7 @@ void gnrc_dhcpv6_client_simple_pd_init(void)
     /* start DHCPv6 client thread to request prefix for WPAN */
     thread_create(_stack, DHCPV6_CLIENT_STACK_SIZE,
                   DHCPV6_CLIENT_PRIORITY,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _dhcpv6_cl_simple_pd_thread, NULL, "dhcpv6-client");
 }
 
diff --git a/sys/net/gnrc/application_layer/uhcpc/gnrc_uhcpc.c b/sys/net/gnrc/application_layer/uhcpc/gnrc_uhcpc.c
index 57a714ce2f..d6cb7af0a8 100644
--- a/sys/net/gnrc/application_layer/uhcpc/gnrc_uhcpc.c
+++ b/sys/net/gnrc/application_layer/uhcpc/gnrc_uhcpc.c
@@ -111,6 +111,6 @@ void auto_init_gnrc_uhcpc(void)
 
     /* initiate uhcp client */
     thread_create(_uhcp_client_stack, sizeof(_uhcp_client_stack),
-            THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+            THREAD_PRIORITY_MAIN - 1, 0,
             uhcp_client_thread, NULL, "uhcp");
 }
diff --git a/sys/net/gnrc/netif/gnrc_netif.c b/sys/net/gnrc/netif/gnrc_netif.c
index 7ae1cb49de..8ececfad03 100644
--- a/sys/net/gnrc/netif/gnrc_netif.c
+++ b/sys/net/gnrc/netif/gnrc_netif.c
@@ -92,7 +92,7 @@ int gnrc_netif_create(gnrc_netif_t *netif, char *stack, int stacksize,
     mutex_init(&ctx.init_done);
     mutex_lock(&ctx.init_done);
 
-    res = thread_create(stack, stacksize, priority, THREAD_CREATE_STACKTEST,
+    res = thread_create(stack, stacksize, priority, 0,
                         _gnrc_netif_thread, &ctx, name);
     assert(res > 0);
     (void)res;
diff --git a/sys/net/gnrc/network_layer/ipv6/gnrc_ipv6.c b/sys/net/gnrc/network_layer/ipv6/gnrc_ipv6.c
index cb3ae5a12c..fea9c412b6 100644
--- a/sys/net/gnrc/network_layer/ipv6/gnrc_ipv6.c
+++ b/sys/net/gnrc/network_layer/ipv6/gnrc_ipv6.c
@@ -85,7 +85,7 @@ kernel_pid_t gnrc_ipv6_init(void)
 {
     if (gnrc_ipv6_pid == KERNEL_PID_UNDEF) {
         gnrc_ipv6_pid = thread_create(_stack, sizeof(_stack), GNRC_IPV6_PRIO,
-                                      THREAD_CREATE_STACKTEST,
+                                      0,
                                       _event_loop, NULL, "ipv6");
     }
 
diff --git a/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c b/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c
index 3a664bd595..b5699d0d04 100644
--- a/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c
+++ b/sys/net/gnrc/network_layer/sixlowpan/gnrc_sixlowpan.c
@@ -52,7 +52,7 @@ kernel_pid_t gnrc_sixlowpan_init(void)
     }
 
     _pid = thread_create(_stack, sizeof(_stack), GNRC_SIXLOWPAN_PRIO,
-                         THREAD_CREATE_STACKTEST, _event_loop, NULL, "6lo");
+                         0, _event_loop, NULL, "6lo");
 
     return _pid;
 }
diff --git a/sys/net/gnrc/pktdump/gnrc_pktdump.c b/sys/net/gnrc/pktdump/gnrc_pktdump.c
index 58b5502efc..f0539815fe 100644
--- a/sys/net/gnrc/pktdump/gnrc_pktdump.c
+++ b/sys/net/gnrc/pktdump/gnrc_pktdump.c
@@ -199,7 +199,7 @@ kernel_pid_t gnrc_pktdump_init(void)
 {
     if (gnrc_pktdump_pid == KERNEL_PID_UNDEF) {
         gnrc_pktdump_pid = thread_create(_stack, sizeof(_stack), GNRC_PKTDUMP_PRIO,
-                             THREAD_CREATE_STACKTEST,
+                             0,
                              _eventloop, NULL, "pktdump");
     }
     return gnrc_pktdump_pid;
diff --git a/sys/net/gnrc/routing/ipv6_auto_subnets/gnrc_ipv6_auto_subnets.c b/sys/net/gnrc/routing/ipv6_auto_subnets/gnrc_ipv6_auto_subnets.c
index 7386da006c..042d1e7193 100644
--- a/sys/net/gnrc/routing/ipv6_auto_subnets/gnrc_ipv6_auto_subnets.c
+++ b/sys/net/gnrc/routing/ipv6_auto_subnets/gnrc_ipv6_auto_subnets.c
@@ -714,7 +714,7 @@ void gnrc_ipv6_auto_subnets_init(void)
 {
     /* initiate auto_subnets thread */
     _server_pid = thread_create(auto_subnets_stack, sizeof(auto_subnets_stack),
-                                THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                                THREAD_PRIORITY_MAIN - 1, 0,
                                 _eventloop, NULL, "auto_subnets");
 }
 #endif /* !IS_USED(MODULE_GNRC_IPV6_AUTO_SUBNETS_SIMPLE) */
diff --git a/sys/net/gnrc/routing/rpl/gnrc_rpl.c b/sys/net/gnrc/routing/rpl/gnrc_rpl.c
index 383637b295..19e6b761c7 100644
--- a/sys/net/gnrc/routing/rpl/gnrc_rpl.c
+++ b/sys/net/gnrc/routing/rpl/gnrc_rpl.c
@@ -87,7 +87,7 @@ kernel_pid_t gnrc_rpl_init(kernel_pid_t if_pid)
         _instance_id = 0;
         /* start the event loop */
         gnrc_rpl_pid = thread_create(_stack, sizeof(_stack), GNRC_RPL_PRIO,
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      _event_loop, (void*)&eventloop_startup,
                                      "RPL");
 
diff --git a/sys/net/gnrc/transport_layer/tcp/gnrc_tcp_eventloop.c b/sys/net/gnrc/transport_layer/tcp/gnrc_tcp_eventloop.c
index d03cce3a4a..e869f6b5af 100644
--- a/sys/net/gnrc/transport_layer/tcp/gnrc_tcp_eventloop.c
+++ b/sys/net/gnrc/transport_layer/tcp/gnrc_tcp_eventloop.c
@@ -382,7 +382,7 @@ int _gnrc_tcp_eventloop_init(void)
     evtimer_init_msg(&_tcp_msg_timer);
 
     kernel_pid_t pid = thread_create(_stack, sizeof(_stack), TCP_EVENTLOOP_PRIO,
-                                     THREAD_CREATE_STACKTEST, _eventloop, NULL,
+                                     0, _eventloop, NULL,
                                      "gnrc_tcp");
     TCP_DEBUG_LEAVE;
     return pid;
diff --git a/sys/net/gnrc/transport_layer/udp/gnrc_udp.c b/sys/net/gnrc/transport_layer/udp/gnrc_udp.c
index 38c77eeec4..2dd6fcddb7 100644
--- a/sys/net/gnrc/transport_layer/udp/gnrc_udp.c
+++ b/sys/net/gnrc/transport_layer/udp/gnrc_udp.c
@@ -303,7 +303,7 @@ int gnrc_udp_init(void)
     if (_pid == KERNEL_PID_UNDEF) {
         /* start UDP thread */
         _pid = thread_create(_stack, sizeof(_stack), GNRC_UDP_PRIO,
-                             THREAD_CREATE_STACKTEST, _event_loop, NULL, "udp");
+                             0, _event_loop, NULL, "udp");
     }
     return _pid;
 }
diff --git a/sys/posix/pthread/pthread.c b/sys/posix/pthread/pthread.c
index 1abfdd86ce..bdee691c00 100644
--- a/sys/posix/pthread/pthread.c
+++ b/sys/posix/pthread/pthread.c
@@ -156,7 +156,7 @@ int pthread_create(pthread_t *newthread, const pthread_attr_t *attr, void *(*sta
             volatile kernel_pid_t pid = thread_create(pthread_reaper_stack,
                                              PTHREAD_REAPER_STACKSIZE,
                                              0,
-                                             THREAD_CREATE_STACKTEST,
+                                             0,
                                              pthread_reaper,
                                              NULL,
                                              "pthread-reaper");
@@ -176,7 +176,7 @@ int pthread_create(pthread_t *newthread, const pthread_attr_t *attr, void *(*sta
                                    stack_size,
                                    THREAD_PRIORITY_MAIN,
                                    THREAD_CREATE_SLEEPING |
-                                   THREAD_CREATE_STACKTEST,
+                                   0,
                                    pthread_start_routine,
                                    pt,
                                    "pthread");
diff --git a/sys/suit/transport/worker.c b/sys/suit/transport/worker.c
index f4a0bd445e..79ca4c4db8 100644
--- a/sys/suit/transport/worker.c
+++ b/sys/suit/transport/worker.c
@@ -220,7 +220,7 @@ void suit_worker_trigger(const char *url, size_t len)
     _url[len] = '\0';
 
     _worker_pid = thread_create(_stack, SUIT_WORKER_STACKSIZE, SUIT_COAP_WORKER_PRIO,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _suit_worker_thread, NULL, "suit worker");
 }
 
@@ -245,7 +245,7 @@ void suit_worker_trigger_prepared(const uint8_t *buffer, size_t size)
     }
 
     _worker_pid = thread_create(_stack, SUIT_WORKER_STACKSIZE, SUIT_COAP_WORKER_PRIO,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _suit_worker_thread, NULL, "suit worker");
 }
 
diff --git a/sys/test_utils/benchmark_udp/benchmark_udp.c b/sys/test_utils/benchmark_udp/benchmark_udp.c
index 74b70c228e..27a4217260 100644
--- a/sys/test_utils/benchmark_udp/benchmark_udp.c
+++ b/sys/test_utils/benchmark_udp/benchmark_udp.c
@@ -171,10 +171,10 @@ int benchmark_udp_start(const char *server, uint16_t port)
 
     running = true;
     thread_create(listen_thread_stack, sizeof(listen_thread_stack),
-                  THREAD_PRIORITY_MAIN - 2, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 2, 0,
                   _listen_thread, NULL, "UDP receiver");
     thread_create(send_thread_stack, sizeof(send_thread_stack),
-                  THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 1, 0,
                   _send_thread, &remote, "UDP sender");
     return 0;
 }
diff --git a/sys/test_utils/dummy_thread/dummy_thread.c b/sys/test_utils/dummy_thread/dummy_thread.c
index 7bec89f832..45ed112beb 100644
--- a/sys/test_utils/dummy_thread/dummy_thread.c
+++ b/sys/test_utils/dummy_thread/dummy_thread.c
@@ -50,8 +50,6 @@ void dummy_thread_create(void)
 {
     thread_create(_dummy_stack, sizeof(_dummy_stack),
                   THREAD_PRIORITY_IDLE,
-                  THREAD_CREATE_WOUT_YIELD \
-                  | THREAD_CREATE_STACKTEST \
-                  | THREAD_CREATE_SLEEPING,
+                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_SLEEPING,
                   _dummy_thread, NULL, "dummy");
 }
diff --git a/sys/usb/usbus/usbus.c b/sys/usb/usbus/usbus.c
index 37f4b6fc29..db38ca923e 100644
--- a/sys/usb/usbus/usbus.c
+++ b/sys/usb/usbus/usbus.c
@@ -61,7 +61,7 @@ void usbus_init(usbus_t *usbus, usbdev_t *usbdev)
 void usbus_create(char *stack, int stacksize, char priority,
                   const char *name, usbus_t *usbus)
 {
-    int res = thread_create(stack, stacksize, priority, THREAD_CREATE_STACKTEST,
+    int res = thread_create(stack, stacksize, priority, 0,
                             _usbus_thread, (void *)usbus, name);
 
     (void)res;
diff --git a/tests/bench/msg_pingpong/main.c b/tests/bench/msg_pingpong/main.c
index 49181bfbd0..26da8d5472 100644
--- a/tests/bench/msg_pingpong/main.c
+++ b/tests/bench/msg_pingpong/main.c
@@ -59,7 +59,7 @@ int main(void)
     kernel_pid_t other = thread_create(_stack,
                                        sizeof(_stack),
                                        (THREAD_PRIORITY_MAIN - 1),
-                                       THREAD_CREATE_STACKTEST,
+                                       0,
                                        _second_thread,
                                        NULL,
                                        "second_thread");
diff --git a/tests/bench/mutex_pingpong/main.c b/tests/bench/mutex_pingpong/main.c
index bed44025f3..bab7dd9331 100644
--- a/tests/bench/mutex_pingpong/main.c
+++ b/tests/bench/mutex_pingpong/main.c
@@ -59,7 +59,7 @@ int main(void)
     thread_create(_stack,
                   sizeof(_stack),
                   THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                  THREAD_CREATE_WOUT_YIELD,
                   _second_thread,
                   NULL,
                   "second_thread");
diff --git a/tests/bench/thread_flags_pingpong/main.c b/tests/bench/thread_flags_pingpong/main.c
index 84b3ac80a2..e1e92eeb4d 100644
--- a/tests/bench/thread_flags_pingpong/main.c
+++ b/tests/bench/thread_flags_pingpong/main.c
@@ -58,7 +58,7 @@ int main(void)
     kernel_pid_t other = thread_create(_stack,
                                        sizeof(_stack),
                                        (THREAD_PRIORITY_MAIN - 1),
-                                       THREAD_CREATE_STACKTEST,
+                                       0,
                                        _second_thread,
                                        NULL,
                                        "second_thread");
diff --git a/tests/bench/thread_yield_pingpong/main.c b/tests/bench/thread_yield_pingpong/main.c
index aa590f064b..5355336290 100644
--- a/tests/bench/thread_yield_pingpong/main.c
+++ b/tests/bench/thread_yield_pingpong/main.c
@@ -57,7 +57,7 @@ int main(void)
     thread_create(_stack,
                   sizeof(_stack),
                   THREAD_PRIORITY_MAIN,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _second_thread,
                   NULL,
                   "second_thread");
diff --git a/tests/bench/xtimer_load/main.c b/tests/bench/xtimer_load/main.c
index 1f07898ba1..78c0cb75b5 100644
--- a/tests/bench/xtimer_load/main.c
+++ b/tests/bench/xtimer_load/main.c
@@ -160,7 +160,7 @@ int main(void)
     /* create and trigger first background thread */
     kernel_pid_t pid1 = thread_create(slacker_stack1, sizeof(slacker_stack1),
                                       THREAD_PRIORITY_MAIN - 1,
-                                      THREAD_CREATE_STACKTEST,
+                                      0,
                                       slacker_thread, NULL, "slacker1");
 
     LOG_DEBUG("+ msg 1");
@@ -174,7 +174,7 @@ int main(void)
     /* create and trigger second background thread */
     kernel_pid_t pid2 = thread_create(slacker_stack2, sizeof(slacker_stack2),
                                       THREAD_PRIORITY_MAIN - 1,
-                                      THREAD_CREATE_STACKTEST,
+                                      0,
                                       slacker_thread, NULL, "slacker2");
 
     LOG_DEBUG("+ msg 3");
@@ -188,7 +188,7 @@ int main(void)
     /* create and trigger worker thread */
     kernel_pid_t pid3 = thread_create(worker_stack, sizeof(worker_stack),
                                       THREAD_PRIORITY_MAIN - 2,
-                                      THREAD_CREATE_STACKTEST,
+                                      0,
                                       worker_thread, NULL, "worker");
 
     printf("TEST_HZ=%lu\n", TEST_HZ);
diff --git a/tests/core/deferred_yield_higher/main.c b/tests/core/deferred_yield_higher/main.c
index ad86c5ad3d..3380effcc6 100644
--- a/tests/core/deferred_yield_higher/main.c
+++ b/tests/core/deferred_yield_higher/main.c
@@ -37,7 +37,7 @@ int main(void)
     thread_create(
         t2_stack, sizeof(t2_stack),
         THREAD_PRIORITY_MAIN - 1,
-        THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+        THREAD_CREATE_WOUT_YIELD,
         second_thread, NULL, "nr2");
 
     irq_disable();
diff --git a/tests/core/isr_yield_higher/main.c b/tests/core/isr_yield_higher/main.c
index 0b72180885..63822ac032 100644
--- a/tests/core/isr_yield_higher/main.c
+++ b/tests/core/isr_yield_higher/main.c
@@ -61,7 +61,7 @@ int main(void)
     (void)thread_create(
         t2_stack, sizeof(t2_stack),
         THREAD_PRIORITY_MAIN,
-        THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+        THREAD_CREATE_WOUT_YIELD,
         second_thread, NULL, "nr2");
 
     while (xtimer_now_usec() < (TEST_TIME + start_time)) {}
diff --git a/tests/core/mutex_unlock_and_sleep/main.c b/tests/core/mutex_unlock_and_sleep/main.c
index 90bd91e6a0..b3472d0a2e 100644
--- a/tests/core/mutex_unlock_and_sleep/main.c
+++ b/tests/core/mutex_unlock_and_sleep/main.c
@@ -56,7 +56,7 @@ int main(void)
     kernel_pid_t second_pid = thread_create(stack,
                   sizeof(stack),
                   THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                  THREAD_CREATE_WOUT_YIELD,
                   second_thread,
                   NULL,
                   "second_thread");
diff --git a/tests/core/sched_change_priority/main.c b/tests/core/sched_change_priority/main.c
index 57294e613f..f923acb04f 100644
--- a/tests/core/sched_change_priority/main.c
+++ b/tests/core/sched_change_priority/main.c
@@ -86,10 +86,10 @@ static void *t3_func(void *unused)
 int main(void)
 {
     thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN + 1,
-                  THREAD_CREATE_STACKTEST, t2_func, NULL, "t2");
+                  0, t2_func, NULL, "t2");
 
     t3_pid = thread_create(t3_stack, sizeof(t3_stack), THREAD_PRIORITY_MAIN - 1,
-                           THREAD_CREATE_STACKTEST, t3_func, NULL, "t3");
+                           0, t3_func, NULL, "t3");
 
     puts("[main] Use shell command \"nice\" to increase prio of t3.\n"
          "[main] If it works, it will run again. The \"hint\" cmd can be useful.");
diff --git a/tests/core/thread_basic/main.c b/tests/core/thread_basic/main.c
index 457668095a..e5d0be0387 100644
--- a/tests/core/thread_basic/main.c
+++ b/tests/core/thread_basic/main.c
@@ -35,7 +35,7 @@ int main(void)
     (void) thread_create(
             t2_stack, sizeof(t2_stack),
             THREAD_PRIORITY_MAIN - 1,
-            THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+            THREAD_CREATE_WOUT_YIELD,
             second_thread, NULL, "nr2");
     puts("first thread\n");
     return 0;
diff --git a/tests/core/thread_cooperation/main.c b/tests/core/thread_cooperation/main.c
index 4613aa3ca8..41af4695e7 100644
--- a/tests/core/thread_cooperation/main.c
+++ b/tests/core/thread_cooperation/main.c
@@ -78,7 +78,7 @@ int main(void)
         printf("MAIN: create thread, arg: %d\n", arg);
         ths = thread_create(stacks[i], sizeof(stacks[i]),
                             THREAD_PRIORITY_MAIN - 1,
-                            THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                            THREAD_CREATE_WOUT_YIELD,
                             run, NULL, "thread");
 
         if (ths < 0)  {
diff --git a/tests/core/thread_exit/main.c b/tests/core/thread_exit/main.c
index ed4b040bfd..b63b303d81 100644
--- a/tests/core/thread_exit/main.c
+++ b/tests/core/thread_exit/main.c
@@ -50,7 +50,7 @@ void *second_thread(void *arg)
              third_thread_stack,
              sizeof(third_thread_stack),
              THREAD_PRIORITY_MAIN - 2,
-             THREAD_CREATE_STACKTEST,
+             0,
              third_thread,
              NULL,
              "nr3")
@@ -64,7 +64,7 @@ void *second_thread(void *arg)
              third_thread_stack,
              sizeof(third_thread_stack),
              THREAD_PRIORITY_MAIN - 1,
-             THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+             THREAD_CREATE_WOUT_YIELD,
              fourth_thread,
              NULL,
              "nr4")
@@ -84,7 +84,7 @@ int main(void)
              second_thread_stack,
              sizeof(second_thread_stack),
              THREAD_PRIORITY_MAIN - 1,
-             THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+             THREAD_CREATE_WOUT_YIELD,
              second_thread,
              NULL,
              "nr2")
diff --git a/tests/core/thread_flags/main.c b/tests/core/thread_flags/main.c
index cae153f396..27098689db 100644
--- a/tests/core/thread_flags/main.c
+++ b/tests/core/thread_flags/main.c
@@ -74,7 +74,7 @@ int main(void)
     kernel_pid_t pid = thread_create(stack,
                   sizeof(stack),
                   THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _thread,
                   NULL,
                   "second_thread");
diff --git a/tests/core/thread_float/main.c b/tests/core/thread_float/main.c
index a41e0266a9..168f629e07 100644
--- a/tests/core/thread_float/main.c
+++ b/tests/core/thread_float/main.c
@@ -94,13 +94,13 @@ int main(void)
     timeout = 50000000000U / coreclk();
 
     p1 = thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN + 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        thread_1_2_3, (void *)t1_name, t1_name);
     p2 = thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN + 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        thread_1_2_3, (void *)t2_name, t2_name);
     p3 = thread_create(t3_stack, sizeof(t3_stack), THREAD_PRIORITY_MAIN + 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        thread_1_2_3, (void *)t3_name, t3_name);
     puts("THREADS CREATED\n");
 
diff --git a/tests/core/thread_flood/main.c b/tests/core/thread_flood/main.c
index 0ba61374ab..120f4450f9 100644
--- a/tests/core/thread_flood/main.c
+++ b/tests/core/thread_flood/main.c
@@ -46,7 +46,7 @@ int main(void)
         thr_id = thread_create(
             dummy_stack, sizeof(dummy_stack),
             THREAD_PRIORITY_MAIN - 1,
-            THREAD_CREATE_SLEEPING | THREAD_CREATE_STACKTEST,
+            THREAD_CREATE_SLEEPING,
             thread_func, NULL, "dummy");
             ++thr_cnt;
             printf(".");
diff --git a/tests/core/thread_msg/main.c b/tests/core/thread_msg/main.c
index 0e0dbe7638..43517923f5 100644
--- a/tests/core/thread_msg/main.c
+++ b/tests/core/thread_msg/main.c
@@ -87,13 +87,13 @@ int main(void)
 {
     p_main = thread_getpid();
     p1 = thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        thread1, NULL, "nr1");
     p2 = thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        thread2, NULL, "nr2");
     p3 = thread_create(t3_stack, sizeof(t3_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        thread3, NULL, "nr3");
     puts("THREADS CREATED\n");
 
diff --git a/tests/core/thread_msg_block_race/main.c b/tests/core/thread_msg_block_race/main.c
index 9c93115c55..b1f7c710f5 100644
--- a/tests/core/thread_msg_block_race/main.c
+++ b/tests/core/thread_msg_block_race/main.c
@@ -94,7 +94,7 @@ int main(void)
          "sched_run() which was the cause of the bug tested here");
     _sched_next();
     pid = thread_create(_stack, sizeof(_stack), THREAD_PRIORITY_MAIN + 1,
-                        THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                        THREAD_CREATE_WOUT_YIELD,
                         _thread, NULL, "nr2");
     expect(pid != KERNEL_PID_UNDEF);
 
diff --git a/tests/core/thread_msg_block_w_queue/main.c b/tests/core/thread_msg_block_w_queue/main.c
index 521d14f136..cce5738a17 100644
--- a/tests/core/thread_msg_block_w_queue/main.c
+++ b/tests/core/thread_msg_block_w_queue/main.c
@@ -62,7 +62,7 @@ int main(void)
     msg_init_queue(_msg_q, 1);
 
     p_send = thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        sender_thread, NULL, "nr1");
 
     /* step 3: receive first msg from sender_thread*/
diff --git a/tests/core/thread_msg_block_wo_queue/main.c b/tests/core/thread_msg_block_wo_queue/main.c
index 507eb8e751..3cc0f4cda3 100644
--- a/tests/core/thread_msg_block_wo_queue/main.c
+++ b/tests/core/thread_msg_block_wo_queue/main.c
@@ -58,7 +58,7 @@ int main(void)
     p_recv = thread_getpid();
 
     p_send = thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                       THREAD_CREATE_WOUT_YIELD,
                        thread1, NULL, "nr1");
 
     /* step 3: receive first msg from sender_thread*/
diff --git a/tests/core/thread_msg_bus/main.c b/tests/core/thread_msg_bus/main.c
index d17a392e0d..85d58165ee 100644
--- a/tests/core/thread_msg_bus/main.c
+++ b/tests/core/thread_msg_bus/main.c
@@ -108,11 +108,11 @@ int main(void)
 
     p_main = thread_getpid();
     p1 = thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN - 3,
-                       THREAD_CREATE_STACKTEST, thread1, &my_bus, "nr1");
+                       0, thread1, &my_bus, "nr1");
     p2 = thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN - 2,
-                       THREAD_CREATE_STACKTEST, thread2, &my_bus, "nr2");
+                       0, thread2, &my_bus, "nr2");
     p3 = thread_create(t3_stack, sizeof(t3_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_STACKTEST, thread3, &my_bus, "nr3");
+                       0, thread3, &my_bus, "nr3");
     puts("THREADS CREATED");
 
     const char hello[] = "Hello Threads!";
diff --git a/tests/core/thread_msg_seq/main.c b/tests/core/thread_msg_seq/main.c
index ffc9c9077a..d8e2a6c1c8 100644
--- a/tests/core/thread_msg_seq/main.c
+++ b/tests/core/thread_msg_seq/main.c
@@ -56,13 +56,13 @@ int main(void)
     p_main = thread_getpid();
 
     p1 = thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_STACKTEST, sub_thread, "nr1", "nr1");
+                       0, sub_thread, "nr1", "nr1");
 
     p2 = thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_STACKTEST, sub_thread, "nr2", "nr2");
+                       0, sub_thread, "nr2", "nr2");
 
     p3 = thread_create(t3_stack, sizeof(t3_stack), THREAD_PRIORITY_MAIN - 1,
-                       THREAD_CREATE_STACKTEST, sub_thread, "nr3", "nr3");
+                       0, sub_thread, "nr3", "nr3");
     puts("THREADS CREATED\n");
 
     for (int i = 0; i < 3; i++) {
diff --git a/tests/core/thread_priority_inversion/main.c b/tests/core/thread_priority_inversion/main.c
index 1eb809a3fb..e4a9b8cee5 100644
--- a/tests/core/thread_priority_inversion/main.c
+++ b/tests/core/thread_priority_inversion/main.c
@@ -150,15 +150,15 @@ static void *high_handler(void *arg)
 int main(void)
 {
     thread_create(stack_low, sizeof(stack_low),
-                  THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 1, 0,
                   low_handler, NULL, "low");
 
     thread_create(stack_mid, sizeof(stack_mid),
-                  THREAD_PRIORITY_MAIN - 2, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 2, 0,
                   mid_handler, NULL, "mid");
 
     thread_create(stack_high, sizeof(stack_high),
-                  THREAD_PRIORITY_MAIN - 3, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 3, 0,
                   high_handler, NULL, "high");
 
     /* Start low priority thread first, which will start high and mid priority ones after the
diff --git a/tests/core/thread_stack_alignment/main.c b/tests/core/thread_stack_alignment/main.c
index 7a89e2a8bc..ca6a776b36 100644
--- a/tests/core/thread_stack_alignment/main.c
+++ b/tests/core/thread_stack_alignment/main.c
@@ -83,7 +83,7 @@ int main(void)
         printf("Testing for alignment %" PRIuSIZE ": ", i);
         kernel_pid_t p;
         p = thread_create(stack + i, STACKSIZE, THREAD_PRIORITY_MAIN - 1,
-                          THREAD_CREATE_STACKTEST,
+                          0,
                           thread_func, NULL, "test");
         /* we expect that the new thread is scheduled to directly after it is
          * created and this will only continue one the thread has terminated.
diff --git a/tests/core/thread_zombie/main.c b/tests/core/thread_zombie/main.c
index 47df0995dc..cd87c84057 100644
--- a/tests/core/thread_zombie/main.c
+++ b/tests/core/thread_zombie/main.c
@@ -55,7 +55,7 @@ int main(void)
     kernel_pid_t first_pid =  thread_create(
         t2_stack, sizeof(t2_stack),
         THREAD_PRIORITY_MAIN - 1,
-        THREAD_CREATE_SLEEPING | THREAD_CREATE_STACKTEST,
+        THREAD_CREATE_SLEEPING,
         second_thread, (void *)1, "nr1");
 
     #ifdef MODULE_PS
@@ -67,7 +67,7 @@ int main(void)
     kernel_pid_t second_pid =  thread_create(
         t3_stack, sizeof(t3_stack),
         THREAD_PRIORITY_MAIN - 1,
-        THREAD_CREATE_SLEEPING | THREAD_CREATE_STACKTEST,
+        THREAD_CREATE_SLEEPING,
         second_thread, (void *)2, "nr2");
     #ifdef MODULE_PS
     ps();
@@ -78,7 +78,7 @@ int main(void)
     kernel_pid_t third_pid =  thread_create(
         t4_stack, sizeof(t4_stack),
         THREAD_PRIORITY_MAIN - 1,
-        THREAD_CREATE_SLEEPING | THREAD_CREATE_STACKTEST,
+        THREAD_CREATE_SLEEPING,
         second_thread, (void *)3, "nr3");
     #ifdef MODULE_PS
     ps();
@@ -217,7 +217,7 @@ int main(void)
     kernel_pid_t last_pid =  thread_create(
         t2_stack, sizeof(t2_stack),
         THREAD_PRIORITY_MAIN - 1,
-        THREAD_CREATE_SLEEPING | THREAD_CREATE_STACKTEST,
+        THREAD_CREATE_SLEEPING,
         second_thread, (void *)4, "nr4");
 
     #ifdef MODULE_PS
diff --git a/tests/drivers/at86rf215/main.c b/tests/drivers/at86rf215/main.c
index 7729433c28..3fc02215c3 100644
--- a/tests/drivers/at86rf215/main.c
+++ b/tests/drivers/at86rf215/main.c
@@ -169,7 +169,7 @@ int test_init(void)
 {
     /* create battery monitor thread */
     thread_create(batmon_stack, sizeof(batmon_stack), THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST, batmon_thread, NULL, "batmon");
+                  0, batmon_thread, NULL, "batmon");
     return 0;
 }
 
@@ -247,7 +247,7 @@ int main(void)
 
     /* create battery monitor thread */
     thread_create(batmon_stack, sizeof(batmon_stack), THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST, batmon_thread, NULL, "batmon");
+                  0, batmon_thread, NULL, "batmon");
 
     /* start the shell */
     puts("Initialization successful - starting the shell now");
diff --git a/tests/drivers/lis2dh12/main.c b/tests/drivers/lis2dh12/main.c
index e9fafaa0ce..f2e19f1351 100644
--- a/tests/drivers/lis2dh12/main.c
+++ b/tests/drivers/lis2dh12/main.c
@@ -367,7 +367,7 @@ int main(void)
 
     /* processing lis2dh12 acceleration data */
     thread_create(lis2dh12_process_stack, sizeof(lis2dh12_process_stack),
-                  THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 1, 0,
                   lis2dh12_test_process, NULL, "lis2dh12_process");
 #endif /* MODULE_LIS2DH12_INT */
 
diff --git a/tests/drivers/ltc4150/main.c b/tests/drivers/ltc4150/main.c
index 3b784e62ed..cedd2ad98c 100644
--- a/tests/drivers/ltc4150/main.c
+++ b/tests/drivers/ltc4150/main.c
@@ -180,7 +180,7 @@ int main(void)
 
     /* Start the thread that will keep the MCU busy */
     thread_create(busy_thread_stack, sizeof(busy_thread_stack),
-                  THREAD_PRIORITY_MAIN + 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN + 1, 0,
                   busy_thread, NULL, "busy_thread");
 
     print_str("This test will put three levels of load on the MCU:\n"
diff --git a/tests/drivers/pir/main.c b/tests/drivers/pir/main.c
index 53ef6b21b9..a1b190859d 100644
--- a/tests/drivers/pir/main.c
+++ b/tests/drivers/pir/main.c
@@ -82,7 +82,7 @@ int main(void)
 #else
    thread_create(
            pir_handler_stack, sizeof(pir_handler_stack), THREAD_PRIORITY_MAIN - 1,
-           THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+           THREAD_CREATE_WOUT_YIELD,
            pir_handler, NULL, "pir_handler");
 #endif
     return 0;
diff --git a/tests/drivers/sx126x/main.c b/tests/drivers/sx126x/main.c
index 175abd103d..ec4508630a 100644
--- a/tests/drivers/sx126x/main.c
+++ b/tests/drivers/sx126x/main.c
@@ -334,7 +334,7 @@ int main(void)
     }
 
     _recv_pid = thread_create(stack, sizeof(stack), THREAD_PRIORITY_MAIN - 1,
-                              THREAD_CREATE_STACKTEST, _recv_thread, netdev,
+                              0, _recv_thread, netdev,
                               "recv_thread");
 
     if (_recv_pid <= KERNEL_PID_UNDEF) {
diff --git a/tests/drivers/sx127x/main.c b/tests/drivers/sx127x/main.c
index 216fed80a3..9871b1b5e3 100644
--- a/tests/drivers/sx127x/main.c
+++ b/tests/drivers/sx127x/main.c
@@ -553,7 +553,7 @@ int main(void)
     }
 
     _recv_pid = thread_create(stack, sizeof(stack), THREAD_PRIORITY_MAIN - 1,
-                              THREAD_CREATE_STACKTEST, _recv_thread, NULL,
+                              0, _recv_thread, NULL,
                               "recv_thread");
 
     if (_recv_pid <= KERNEL_PID_UNDEF) {
diff --git a/tests/drivers/sx1280/main.c b/tests/drivers/sx1280/main.c
index d90cd3e7d5..7b93150a29 100644
--- a/tests/drivers/sx1280/main.c
+++ b/tests/drivers/sx1280/main.c
@@ -364,7 +364,7 @@ int main(void)
     }
 
     _recv_pid = thread_create(stack, sizeof(stack), THREAD_PRIORITY_MAIN - 1,
-                              THREAD_CREATE_STACKTEST, _recv_thread, netdev,
+                              0, _recv_thread, netdev,
                               "recv_thread");
 
     if (_recv_pid <= KERNEL_PID_UNDEF) {
diff --git a/tests/net/gnrc_dhcpv6_client/main.c b/tests/net/gnrc_dhcpv6_client/main.c
index 19741e5752..448d6b326d 100644
--- a/tests/net/gnrc_dhcpv6_client/main.c
+++ b/tests/net/gnrc_dhcpv6_client/main.c
@@ -59,7 +59,7 @@ int main(void)
 
     _gnrc_netif_config(0, NULL);
     thread_create(_dhcpv6_client_stack, DHCPV6_CLIENT_STACK_SIZE,
-                  DHCPV6_CLIENT_PRIORITY, THREAD_CREATE_STACKTEST,
+                  DHCPV6_CLIENT_PRIORITY, 0,
                   _dhcpv6_client_thread, NULL, "dhcpv6-client");
     xtimer_sleep(5);
     /* global address should now be configured */
diff --git a/tests/net/gnrc_mac_timeout/main.c b/tests/net/gnrc_mac_timeout/main.c
index 78e895a0fd..5721609c1c 100644
--- a/tests/net/gnrc_mac_timeout/main.c
+++ b/tests/net/gnrc_mac_timeout/main.c
@@ -95,7 +95,7 @@ int main(void)
     /* create worker thread */
     kernel_pid_t pid = thread_create(worker_stack, sizeof(worker_stack),
                                      THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      worker_thread, NULL, "worker");
 
     timeout_1 = -1;
diff --git a/tests/net/gnrc_netif_ipv6_wait_for_global_address/main.c b/tests/net/gnrc_netif_ipv6_wait_for_global_address/main.c
index 1dd573de3a..3f3ebda4ef 100644
--- a/tests/net/gnrc_netif_ipv6_wait_for_global_address/main.c
+++ b/tests/net/gnrc_netif_ipv6_wait_for_global_address/main.c
@@ -66,7 +66,7 @@ static void _add_delayed_addr(gnrc_netif_t *netif)
     memset(adder_stack, 0, sizeof(adder_stack));
     thread_create(adder_stack, sizeof(adder_stack),
                   THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   _adder_thread, netif, "add_addr");
 }
 
diff --git a/tests/net/gnrc_udp/udp.c b/tests/net/gnrc_udp/udp.c
index 32eced16ea..2ba794cdc2 100644
--- a/tests/net/gnrc_udp/udp.c
+++ b/tests/net/gnrc_udp/udp.c
@@ -183,7 +183,7 @@ static void start_server(char *port_str)
     if (server_pid <= KERNEL_PID_UNDEF) {
         /* start server */
         server_pid = thread_create(server_stack, sizeof(server_stack), SERVER_PRIO,
-                                   THREAD_CREATE_STACKTEST, _eventloop, NULL, "UDP server");
+                                   0, _eventloop, NULL, "UDP server");
         if (server_pid <= KERNEL_PID_UNDEF) {
             puts("Error: can not start server thread");
             return;
diff --git a/tests/net/sock_udp_aux/main.c b/tests/net/sock_udp_aux/main.c
index fc59420a96..fae95a253b 100644
--- a/tests/net/sock_udp_aux/main.c
+++ b/tests/net/sock_udp_aux/main.c
@@ -115,7 +115,7 @@ int main(void)
     msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE);
 
     thread_create(server_thread_stack, sizeof(server_thread_stack),
-                  THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 1, 0,
                   server_thread, NULL, "UDP echo server");
 
     char line_buf[SHELL_DEFAULT_BUFSIZE];
diff --git a/tests/pkg/lwip/ip.c b/tests/pkg/lwip/ip.c
index 750b174d1b..c3bca5bee5 100644
--- a/tests/pkg/lwip/ip.c
+++ b/tests/pkg/lwip/ip.c
@@ -167,7 +167,7 @@ static int ip_send(char *addr_str, char *port_str, char *data, unsigned int num,
 static int ip_start_server(char *port_str)
 {
     if (thread_create(server_stack, sizeof(server_stack), THREAD_PRIORITY_MAIN - 1,
-                      THREAD_CREATE_STACKTEST, _server_thread, port_str,
+                      0, _server_thread, port_str,
                       "IP server") <= KERNEL_PID_UNDEF) {
         return 1;
     }
diff --git a/tests/pkg/lwip/tcp.c b/tests/pkg/lwip/tcp.c
index c14843c59a..7d087af6c2 100644
--- a/tests/pkg/lwip/tcp.c
+++ b/tests/pkg/lwip/tcp.c
@@ -182,7 +182,7 @@ static int tcp_send(char *data, unsigned int num, unsigned int delay)
 static int tcp_start_server(char *port_str)
 {
     if (thread_create(server_stack, sizeof(server_stack), THREAD_PRIORITY_MAIN - 1,
-                      THREAD_CREATE_STACKTEST, _server_thread, port_str,
+                      0, _server_thread, port_str,
                       "TCP server") <= KERNEL_PID_UNDEF) {
         return 1;
     }
diff --git a/tests/pkg/lwip/udp.c b/tests/pkg/lwip/udp.c
index 74feb17f5d..084289f1eb 100644
--- a/tests/pkg/lwip/udp.c
+++ b/tests/pkg/lwip/udp.c
@@ -129,7 +129,7 @@ static int udp_send(char *addr_str, char *data, unsigned int num,
 static int udp_start_server(char *port_str)
 {
     if (thread_create(server_stack, sizeof(server_stack), THREAD_PRIORITY_MAIN - 1,
-                      THREAD_CREATE_STACKTEST, _server_thread, port_str,
+                      0, _server_thread, port_str,
                       "UDP server") <= KERNEL_PID_UNDEF) {
         return 1;
     }
diff --git a/tests/pkg/lwip_sock_tcp/main.c b/tests/pkg/lwip_sock_tcp/main.c
index 5c5cc23921..76639399ac 100644
--- a/tests/pkg/lwip_sock_tcp/main.c
+++ b/tests/pkg/lwip_sock_tcp/main.c
@@ -968,10 +968,10 @@ int main(void)
     printf("code 0x%02x\n", code);
     _net_init();
     expect(0 < thread_create(_client_stack, sizeof(_client_stack),
-                             THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                             THREAD_PRIORITY_MAIN - 1, 0,
                              _client_func, NULL, "tcp_client"));
     expect(0 < thread_create(_server_stack, sizeof(_server_stack),
-                             THREAD_PRIORITY_MAIN - 2, THREAD_CREATE_STACKTEST,
+                             THREAD_PRIORITY_MAIN - 2, 0,
                              _server_func, NULL, "tcp_server"));
     tear_down();
 #ifdef MODULE_LWIP_IPV4
diff --git a/tests/pkg/tinyusb_cdc_msc/main.c b/tests/pkg/tinyusb_cdc_msc/main.c
index 06dbfd5214..37d9f0fcb4 100644
--- a/tests/pkg/tinyusb_cdc_msc/main.c
+++ b/tests/pkg/tinyusb_cdc_msc/main.c
@@ -85,7 +85,7 @@ int main(void)
 
     thread_create(led_thread_stack, sizeof(led_thread_stack),
                   THREAD_PRIORITY_MAIN + 1,
-                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                  THREAD_CREATE_WOUT_YIELD,
                   led_thread_impl, NULL, "led");
 
     if (!IS_USED(MODULE_AUTO_INIT)) {
diff --git a/tests/sys/atomic_utils/main.c b/tests/sys/atomic_utils/main.c
index 5abb4eb3d9..615f8f875d 100644
--- a/tests/sys/atomic_utils/main.c
+++ b/tests/sys/atomic_utils/main.c
@@ -1322,13 +1322,13 @@ static int sc_list(int argc, char **argv)
 int main(void)
 {
     thread_create(thread_worker_stack, sizeof(thread_worker_stack),
-                  THREAD_PRIORITY_MAIN + 2, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN + 2, 0,
                   thread_worker_func, NULL, "worker");
     thread_create(thread_checker_stack, sizeof(thread_checker_stack),
-                  THREAD_PRIORITY_MAIN + 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN + 1, 0,
                   thread_checker_func, NULL, "checker");
     thread_create(thread_timeout_stack, sizeof(thread_timeout_stack),
-                  THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                  THREAD_PRIORITY_MAIN - 1, 0,
                   thread_timeout_func, NULL, "timeout");
 
     print_str(
diff --git a/tests/sys/conn_can/main.c b/tests/sys/conn_can/main.c
index 246b603119..2a588905d6 100644
--- a/tests/sys/conn_can/main.c
+++ b/tests/sys/conn_can/main.c
@@ -732,7 +732,7 @@ int main(void)
     for (intptr_t i = 0; i < RCV_THREAD_NUMOF; i++) {
         receive_pid[i] = thread_create(thread_stack[i], THREAD_STACKSIZE,
                                        THREAD_PRIORITY_MAIN - 1,
-                                       THREAD_CREATE_STACKTEST, _receive_thread,
+                                       0, _receive_thread,
                                        (void*)i, "receive_thread");
     }
 
diff --git a/tests/sys/evtimer_msg/main.c b/tests/sys/evtimer_msg/main.c
index 59e4f6de14..ab7e494461 100644
--- a/tests/sys/evtimer_msg/main.c
+++ b/tests/sys/evtimer_msg/main.c
@@ -69,7 +69,7 @@ int main(void)
     /* create worker thread */
     kernel_pid_t pid = thread_create(worker_stack, sizeof(worker_stack),
                                      THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      worker_thread, NULL, "worker");
 
     printf("Testing generic evtimer\n");
diff --git a/tests/sys/evtimer_underflow/main.c b/tests/sys/evtimer_underflow/main.c
index 43ecfb2122..6739b51762 100644
--- a/tests/sys/evtimer_underflow/main.c
+++ b/tests/sys/evtimer_underflow/main.c
@@ -71,7 +71,7 @@ int main(void)
     /* create worker thread */
     kernel_pid_t pid = thread_create(worker_stack, sizeof(worker_stack),
                                      THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      worker_thread, NULL, "worker");
 
     while (1) {
diff --git a/tests/sys/malloc_thread_safety/main.c b/tests/sys/malloc_thread_safety/main.c
index b6a4fbe652..cd926acc3d 100644
--- a/tests/sys/malloc_thread_safety/main.c
+++ b/tests/sys/malloc_thread_safety/main.c
@@ -112,9 +112,9 @@ int main(void)
     for (size_t i = 0; i < ARRAY_SIZE(funcs); i++) {
         printf("Testing: %s\n", tests[i]);
         t1 = thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN + 1,
-                           THREAD_CREATE_STACKTEST, funcs[i], NULL, "t1");
+                           0, funcs[i], NULL, "t1");
         t2 = thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN + 1,
-                           THREAD_CREATE_STACKTEST, funcs[i], NULL, "t2");
+                           0, funcs[i], NULL, "t2");
         expect((t1 != KERNEL_PID_UNDEF) && (t2 != KERNEL_PID_UNDEF));
 
         for (uint16_t i = 0; i < 2 * MS_PER_SEC; i++) {
diff --git a/tests/sys/pipe/main.c b/tests/sys/pipe/main.c
index 709a86af32..7333f51182 100644
--- a/tests/sys/pipe/main.c
+++ b/tests/sys/pipe/main.c
@@ -101,11 +101,11 @@ int main(void)
 
     thread_create(stacks[0], sizeof (stacks[0]),
                   THREAD_PRIORITY_MAIN,
-                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                  THREAD_CREATE_WOUT_YIELD,
                   run_middle, NULL, "middle");
     thread_create(stacks[1], sizeof (stacks[1]),
                   THREAD_PRIORITY_MAIN,
-                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                  THREAD_CREATE_WOUT_YIELD,
                   run_end, NULL, "end");
 
     unsigned total = 0;
diff --git a/tests/sys/posix_semaphore/main.c b/tests/sys/posix_semaphore/main.c
index fc3a175e84..2840d02dc9 100644
--- a/tests/sys/posix_semaphore/main.c
+++ b/tests/sys/posix_semaphore/main.c
@@ -78,7 +78,7 @@ static void test1(void)
     kernel_pid_t pid = thread_create(test1_thread_stack,
                                      sizeof(test1_thread_stack),
                                      THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_STACKTEST,
+                                     0,
                                      test1_second_thread,
                                      NULL,
                                      "second");
@@ -156,7 +156,7 @@ void test2(void)
         kernel_pid_t pid = thread_create(test2_thread_stack[i],
                                          sizeof(test2_thread_stack[i]),
                                          priority,
-                                         THREAD_CREATE_STACKTEST,
+                                         0,
                                          priority_sema_thread,
                                          names[i],
                                          names[i]);
@@ -215,14 +215,14 @@ void test3(void)
     }
     puts("first: create thread 1");
     if (thread_create(test2_thread_stack[0], sizeof(test2_thread_stack[0]),
-                      THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                      THREAD_PRIORITY_MAIN - 1, 0,
                       test3_one_two_thread, NULL, "thread 1") < 0) {
         puts("first: thread create FAILED");
         return;
     }
     puts("first: create thread 2");
     if (thread_create(test2_thread_stack[1], sizeof(test2_thread_stack[1]),
-                      THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
+                      THREAD_PRIORITY_MAIN - 1, 0,
                       test3_two_one_thread, NULL, "thread 2") < 0) {
         puts("first: thread create FAILED");
         return;
diff --git a/tests/sys/ps_schedstatistics/main.c b/tests/sys/ps_schedstatistics/main.c
index 308c891d4d..b13e178429 100644
--- a/tests/sys/ps_schedstatistics/main.c
+++ b/tests/sys/ps_schedstatistics/main.c
@@ -62,7 +62,7 @@ int main(void)
     for (uintptr_t i = 0; i < NB_THREADS; ++i) {
         pids[i] = thread_create(stacks[i], sizeof(stacks[i]),
                                 THREAD_PRIORITY_MAIN - 1,
-                                THREAD_CREATE_STACKTEST,
+                                0,
                                 _thread_fn, (void *)i, "thread");
     }
     /* sleep for a second, so that `ps` shows some % on idle at the beginning */
diff --git a/tests/sys/pthread_condition_variable/main.c b/tests/sys/pthread_condition_variable/main.c
index c9c5eebd04..eaffe3338e 100644
--- a/tests/sys/pthread_condition_variable/main.c
+++ b/tests/sys/pthread_condition_variable/main.c
@@ -63,7 +63,7 @@ int main(void)
     pthread_cond_init(&cv, NULL);
 
     kernel_pid_t pid = thread_create(stack,sizeof(stack), THREAD_PRIORITY_MAIN - 1,
-                                     THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                                     THREAD_CREATE_WOUT_YIELD,
                                      second_thread, NULL, "second_thread");
 
     while (1) {
diff --git a/tests/sys/pthread_rwlock/main.c b/tests/sys/pthread_rwlock/main.c
index 443807bbb1..447a2cd8ca 100644
--- a/tests/sys/pthread_rwlock/main.c
+++ b/tests/sys/pthread_rwlock/main.c
@@ -159,7 +159,7 @@ int main(void)
         }
 
         thread_create(stacks[i], sizeof(stacks[i]),
-                      prio, THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                      prio, THREAD_CREATE_WOUT_YIELD,
                       fun, NULL, name);
     }
 
diff --git a/tests/sys/sched_round_robin/main.c b/tests/sys/sched_round_robin/main.c
index 4626da8390..0e2dfbde7d 100644
--- a/tests/sys/sched_round_robin/main.c
+++ b/tests/sys/sched_round_robin/main.c
@@ -53,9 +53,9 @@ int main(void)
 {
     puts("starting threads");
     main_pid = thread_getpid();
-    thread_create(stack[0], sizeof(stack[0]), shared_prio, THREAD_CREATE_STACKTEST,
+    thread_create(stack[0], sizeof(stack[0]), shared_prio, 0,
                   thread_wakeup_main, NULL, "TWakeup");
-    thread_create(stack[1], sizeof(stack[1]), shared_prio, THREAD_CREATE_STACKTEST,
+    thread_create(stack[1], sizeof(stack[1]), shared_prio, 0,
                   thread_bad, NULL, "TBad");
     puts("main is going to sleep");
     thread_sleep();
diff --git a/tests/sys/sema/main.c b/tests/sys/sema/main.c
index 48ee5edd2b..2d6e8934de 100644
--- a/tests/sys/sema/main.c
+++ b/tests/sys/sema/main.c
@@ -86,7 +86,7 @@ int main(void)
     thread_create(stack,
                   sizeof(stack),
                   THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_WOUT_YIELD | THREAD_CREATE_STACKTEST,
+                  THREAD_CREATE_WOUT_YIELD,
                   second_thread,
                   &thread_success,
                   "second_thread");
diff --git a/tests/sys/sema_inv/main.c b/tests/sys/sema_inv/main.c
index c0414a61c5..e27b4fea42 100644
--- a/tests/sys/sema_inv/main.c
+++ b/tests/sys/sema_inv/main.c
@@ -76,11 +76,11 @@ static void test_counter_mode(void)
     sema_inv_init(&sync, 3);
 
     thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST, thread_count, &ctx[0], "nr1");
+                  0, thread_count, &ctx[0], "nr1");
     thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN + 1,
-                  THREAD_CREATE_STACKTEST, thread_count, &ctx[1], "nr2");
+                  0, thread_count, &ctx[1], "nr2");
     thread_create(t3_stack, sizeof(t3_stack), THREAD_PRIORITY_MAIN + 1,
-                  THREAD_CREATE_STACKTEST, thread_count, &ctx[2], "nr3");
+                  0, thread_count, &ctx[2], "nr3");
 
     sema_inv_wait(&sync);
     puts("thread synced");
@@ -103,11 +103,11 @@ static void test_mask_mode(void)
     sema_inv_init(&sync, 0xE);
 
     thread_create(t1_stack, sizeof(t1_stack), THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST, thread_bit, &ctx[0], "nr1");
+                  0, thread_bit, &ctx[0], "nr1");
     thread_create(t2_stack, sizeof(t2_stack), THREAD_PRIORITY_MAIN + 1,
-                  THREAD_CREATE_STACKTEST, thread_bit, &ctx[1], "nr2");
+                  0, thread_bit, &ctx[1], "nr2");
     thread_create(t3_stack, sizeof(t3_stack), THREAD_PRIORITY_MAIN + 1,
-                  THREAD_CREATE_STACKTEST, thread_bit, &ctx[2], "nr3");
+                  0, thread_bit, &ctx[2], "nr3");
 
     sema_inv_wait(&sync);
     puts("thread synced");
diff --git a/tests/sys/xtimer_drift/main.c b/tests/sys/xtimer_drift/main.c
index 534e809206..60fe32fdb4 100644
--- a/tests/sys/xtimer_drift/main.c
+++ b/tests/sys/xtimer_drift/main.c
@@ -138,7 +138,7 @@ int main(void)
     /* create and trigger first background thread */
     kernel_pid_t pid1 = thread_create(slacker_stack1, sizeof(slacker_stack1),
                                       THREAD_PRIORITY_MAIN - 1,
-                                      THREAD_CREATE_STACKTEST,
+                                      0,
                                       slacker_thread, NULL, "slacker1");
 
     LOG_DEBUG("+ msg 1");
@@ -152,7 +152,7 @@ int main(void)
     /* create and trigger second background thread */
     kernel_pid_t pid2 = thread_create(slacker_stack2, sizeof(slacker_stack2),
                                       THREAD_PRIORITY_MAIN - 1,
-                                      THREAD_CREATE_STACKTEST,
+                                      0,
                                       slacker_thread, NULL, "slacker2");
 
     LOG_DEBUG("+ msg 3");
@@ -166,7 +166,7 @@ int main(void)
     /* create and trigger worker thread */
     kernel_pid_t pid3 = thread_create(worker_stack, sizeof(worker_stack),
                                       THREAD_PRIORITY_MAIN - 2,
-                                      THREAD_CREATE_STACKTEST,
+                                      0,
                                       worker_thread, NULL, "worker");
 
     puts("[START]\n");
diff --git a/tests/sys/xtimer_hang/main.c b/tests/sys/xtimer_hang/main.c
index a74bb80b11..be7c608081 100644
--- a/tests/sys/xtimer_hang/main.c
+++ b/tests/sys/xtimer_hang/main.c
@@ -84,10 +84,10 @@ int main(void)
     LOG_DEBUG("[INIT]\n");
 
     thread_create(stack_timer1, TEST_TIMER_STACKSIZE,
-                  2, THREAD_CREATE_STACKTEST,
+                  2, 0,
                   timer_func, &sleep_timer1, "timer1");
     thread_create(stack_timer2, TEST_TIMER_STACKSIZE,
-                  3, THREAD_CREATE_STACKTEST,
+                  3, 0,
                   timer_func, &sleep_timer2, "timer2");
 
     uint32_t now = 0;
diff --git a/tests/sys/xtimer_msg/main.c b/tests/sys/xtimer_msg/main.c
index 4ad7262f35..23e7bbc317 100644
--- a/tests/sys/xtimer_msg/main.c
+++ b/tests/sys/xtimer_msg/main.c
@@ -100,7 +100,7 @@ int main(void)
                   timer_stack,
                   sizeof(timer_stack),
                   THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   timer_thread,
                   NULL,
                   "timer");
@@ -119,7 +119,7 @@ int main(void)
                    timer_stack_local,
                    sizeof(timer_stack_local),
                    THREAD_PRIORITY_MAIN - 1,
-                   THREAD_CREATE_STACKTEST,
+                   0,
                    timer_thread_local,
                    NULL,
                    "timer local");
diff --git a/tests/sys/xtimer_mutex_lock_timeout/main.c b/tests/sys/xtimer_mutex_lock_timeout/main.c
index 4f30611d6e..d7ea5bc4cf 100644
--- a/tests/sys/xtimer_mutex_lock_timeout/main.c
+++ b/tests/sys/xtimer_mutex_lock_timeout/main.c
@@ -225,7 +225,7 @@ static int cmd_test_xtimer_mutex_lock_timeout_low_prio_thread(int argc,
     printf("threads = %d\n", current_thread_count);
     kernel_pid_t test_thread = thread_create(t_stack, sizeof(t_stack),
                                              THREAD_PRIORITY_MAIN + 1,
-                                             THREAD_CREATE_STACKTEST,
+                                             0,
                                              thread_low_prio_test,
                                              (void *)&test_mutex,
                                              "thread_low_prio_test");
diff --git a/tests/sys/xtimer_rmutex_lock_timeout/main.c b/tests/sys/xtimer_rmutex_lock_timeout/main.c
index 35ad64e51e..915b9e36ff 100644
--- a/tests/sys/xtimer_rmutex_lock_timeout/main.c
+++ b/tests/sys/xtimer_rmutex_lock_timeout/main.c
@@ -200,7 +200,7 @@ static int cmd_test_xtimer_rmutex_lock_timeout_long_locked(int argc,
     /* lock rmutex from different thread */
     kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
                                                THREAD_PRIORITY_MAIN - 1,
-                                               THREAD_CREATE_STACKTEST,
+                                               0,
                                                lock_rmutex_thread,
                                                (void *)&test_rmutex,
                                                "lock_thread");
@@ -252,7 +252,7 @@ static int cmd_test_xtimer_rmutex_lock_timeout_low_prio_thread(
 
     kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
                                                THREAD_PRIORITY_MAIN + 1,
-                                               THREAD_CREATE_STACKTEST,
+                                               0,
                                                test_thread,
                                                (void *)&test_rmutex,
                                                "test_thread");
@@ -306,7 +306,7 @@ static int cmd_test_xtimer_rmutex_lock_timeout_short_locked(int argc,
 
     kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
                                                THREAD_PRIORITY_MAIN - 1,
-                                               THREAD_CREATE_STACKTEST,
+                                               0,
                                                lock_rmutex_thread,
                                                (void *)&test_rmutex,
                                                "lock_thread");
diff --git a/tests/sys/ztimer64_msg/main.c b/tests/sys/ztimer64_msg/main.c
index a27dd9cc5d..c6133a1ec3 100644
--- a/tests/sys/ztimer64_msg/main.c
+++ b/tests/sys/ztimer64_msg/main.c
@@ -119,7 +119,7 @@ int main(void)
         timer_stack,
         sizeof(timer_stack),
         THREAD_PRIORITY_MAIN - 1,
-        THREAD_CREATE_STACKTEST,
+        0,
         timer_thread,
         NULL,
         "timer");
@@ -138,7 +138,7 @@ int main(void)
         timer_stack_local,
         sizeof(timer_stack_local),
         THREAD_PRIORITY_MAIN - 1,
-        THREAD_CREATE_STACKTEST,
+        0,
         timer_thread_local,
         NULL,
         "timer local");
diff --git a/tests/sys/ztimer_msg/main.c b/tests/sys/ztimer_msg/main.c
index 24e52a0bcb..ca13330eb2 100644
--- a/tests/sys/ztimer_msg/main.c
+++ b/tests/sys/ztimer_msg/main.c
@@ -115,7 +115,7 @@ int main(void)
                   timer_stack,
                   sizeof(timer_stack),
                   THREAD_PRIORITY_MAIN - 1,
-                  THREAD_CREATE_STACKTEST,
+                  0,
                   timer_thread,
                   NULL,
                   "timer");
@@ -134,7 +134,7 @@ int main(void)
                    timer_stack_local,
                    sizeof(timer_stack_local),
                    THREAD_PRIORITY_MAIN - 1,
-                   THREAD_CREATE_STACKTEST,
+                   0,
                    timer_thread_local,
                    NULL,
                    "timer local");
diff --git a/tests/sys/ztimer_rmutex_lock_timeout/main.c b/tests/sys/ztimer_rmutex_lock_timeout/main.c
index fb063c53e4..d4f421d0ff 100644
--- a/tests/sys/ztimer_rmutex_lock_timeout/main.c
+++ b/tests/sys/ztimer_rmutex_lock_timeout/main.c
@@ -193,7 +193,7 @@ static int cmd_test_ztimer_rmutex_lock_timeout_long_locked(int argc,
     /* lock rmutex from different thread */
     kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
                                                THREAD_PRIORITY_MAIN - 1,
-                                               THREAD_CREATE_STACKTEST,
+                                               0,
                                                lock_rmutex_thread,
                                                (void *)&test_rmutex,
                                                "lock_thread");
@@ -245,7 +245,7 @@ static int cmd_test_ztimer_rmutex_lock_timeout_low_prio_thread(
 
     kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
                                                THREAD_PRIORITY_MAIN + 1,
-                                               THREAD_CREATE_STACKTEST,
+                                               0,
                                                test_thread,
                                                (void *)&test_rmutex,
                                                "test_thread");
@@ -299,7 +299,7 @@ static int cmd_test_ztimer_rmutex_lock_timeout_short_locked(int argc,
 
     kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
                                                THREAD_PRIORITY_MAIN - 1,
-                                               THREAD_CREATE_STACKTEST,
+                                               0,
                                                lock_rmutex_thread,
                                                (void *)&test_rmutex,
                                                "lock_thread");
diff --git a/tests/unittests/tests-bhp_msg/tests-bhp_msg.c b/tests/unittests/tests-bhp_msg/tests-bhp_msg.c
index 1efd70fb5c..193fc479ae 100644
--- a/tests/unittests/tests-bhp_msg/tests-bhp_msg.c
+++ b/tests/unittests/tests-bhp_msg/tests-bhp_msg.c
@@ -72,7 +72,7 @@ static void test_bhp_msg__claim(void)
 static void test_bhp_msg__cb(void)
 {
     kernel_pid_t pid = thread_create(_stack, sizeof(_stack), THREAD_PRIORITY_MAIN - 1,
-                             THREAD_CREATE_STACKTEST, _event_loop, NULL,
+                             0, _event_loop, NULL,
                              "bhp_msg");
 
     bhp_msg_claim_thread(&bhp_msg, pid);
diff --git a/tests/unittests/tests-core/tests-core-ringbuffer.c b/tests/unittests/tests-core/tests-core-ringbuffer.c
index be0f56afe7..38d7d93475 100644
--- a/tests/unittests/tests-core/tests-core-ringbuffer.c
+++ b/tests/unittests/tests-core/tests-core-ringbuffer.c
@@ -109,7 +109,7 @@ static void tests_core_ringbuffer(void)
     pid_add = thread_getpid();
     pid_get = thread_create(stack_get, sizeof (stack_get),
                             THREAD_PRIORITY_MAIN,
-                            THREAD_CREATE_SLEEPING | THREAD_CREATE_STACKTEST,
+                            THREAD_CREATE_SLEEPING,
                             run_get, NULL, "get");
     run_add();
 }