I korthet
Den grova ungdomsbrottsligheten utgör ett allvarligt hot i det svenska samhället. Den kommer att ta lång tid att åtgärda, och lagstiftningen måste därför utredas. Mycket tyder på att problemet dessutom ökar genom rekrytering av allt yngre barn i utsatta områden. Den mest centrala aktören för att motverka det, socialtjänsten, har stora brister och saknar rätt kompetens.
<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/michael-tarnfalk/">Michael&nbsp;Tärnfalk</a> | 22 juni 2022<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fungdomsvard-vid-vags-ande%2F&amp;t=Ungdomsv%C3%A5rden+har+n%C3%A5tt+v%C3%A4gs+%C3%A4nde"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Ungdomsv%C3%A5rden+har+n%C3%A5tt+v%C3%A4gs+%C3%A4nde+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fungdomsvard-vid-vags-ande%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fungdomsvard-vid-vags-ande%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ungdomsvården har nått vägs ände&body=https://kvartal.se/artiklar/ungdomsvard-vid-vags-ande/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/70130/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/70130/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fungdomsvard-vid-vags-ande%2F&amp;t=Ungdomsv%C3%A5rden+har+n%C3%A5tt+v%C3%A4gs+%C3%A4nde"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Ungdomsv%C3%A5rden+har+n%C3%A5tt+v%C3%A4gs+%C3%A4nde+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fungdomsvard-vid-vags-ande%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fungdomsvard-vid-vags-ande%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ungdomsvården har nått vägs ände&body=https://kvartal.se/artiklar/ungdomsvard-vid-vags-ande/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/70130/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/70130/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 17 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/70130"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-70130">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "70130"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Den grova ungdomsbrottsligheten utgör ett allvarligt hot i det svenska samhället. Den kommer att ta lång tid att åtgärda, och lagstiftningen måste därför utredas. Mycket tyder på att problemet dessutom ökar genom rekrytering av allt yngre barn i utsatta områden. Den mest centrala aktören för att motverka det, socialtjänsten, har stora brister och saknar rätt kompetens.</p>
</div>
<div class="rest-of-article ">
<p>Vad ska samhället göra med de unga grovt kriminella? Låt oss börja med påföljdssystemets och socialtjänstens brister när det gäller ansvar för unga kriminella under 18 år, därefter se vad forskningen säger om behandling och slutligen peka på några centrala förändringar som krävs.</p>
<h2>Behandling i stället för straff</h2>
<p>Den svenska påföljdsmodellen bygger på behandlingstanken. Idén bygger på att barns brott beror på problem under utvecklingsprocessen och att socialtjänsten har bättre förutsättningar att behandla den unge utifrån dennes behov. Detta kallas behovsprincipen och bygger på förhoppningen om att rehabilitera utsatta barn. Straffbarhetsåldern på 15 år är ett sätt att undvika att barn som begår brott dras in i straffrättsliga processer. När det ändå sker särbehandlas barnet i flera avseenden eftersom straffrättsliga reaktioner kan skada barnets känsliga utvecklingsprocess.<sup>1</sup></p>
<p>I grunden finns en konflikt mellan barnets skyddsbehov å ena sidan och samhällsskyddet å andra sidan.</p>
<p>Minderåriga barn får inte straffas utan ska tas om hand av socialtjänsten. Vissa åtgärder kan ske med stöd av lagen med särskilda bestämmelser om unga lagöverträdare, kallad LUL. Barns brott ska utredas om brottet kan leda till minst ett års fängelse. Socialtjänsten kan också begära att brottet utreds (31 §).</p>
<blockquote><p>Barn kan frivilligt eller på grund av hot ta på sig äldre ungdomars brott.</p></blockquote>
<p>När brottet är utrett kan det hjälpa socialtjänsten att bestämma om en social åtgärd, vanligen samtal, insatser för familjen eller mer sällan placering i familjehem eller på institution.</p>
<p>Men, straffriheten för minderåriga barn gör dem samtidigt intressanta i kriminella kretsar. Barn kan frivilligt eller på grund av hot ta på sig äldre ungdomars brott. Ett sådant ”brottsansvarsövertagande” kan till exempel innebära ökad status och andra favörer i den kriminella gruppen. Paradoxalt nog kan skyddstanken för utsatta barn få motsatt effekt och förvärra yngre barns kriminalitet. Socialtjänstens ansvar för att undvika att barn dras in i sådana miljöer är därför oerhört stort.</p>
<p>Unga mellan 15 och 17 år är straffbara och kan därför åtalas för brott. Påföljderna är böter, ungdomstjänst, ungdomsvård, ungdomsövervakning och sluten ungdomsvård. Särbehandlingen av unga medför att domstol får döma till lindrigare påföljd än vad som annars gäller för brottet – det kallas straffrabatt – och att de inte kan dömas till livstids fängelse vid till exempel mord.<sup>2</sup></p>
<p>Straffvärdesprincipen, att brottets allvar ska avspeglas i straffets hårdhet, har stort utrymme vid påföljder för unga brottslingar, men grundprincipen är att unga i första hand ska överlämnas till socialtjänstens behandling.<sup>3 4</sup></p>
<h2>”Att brösta en fyra för att bli en hundragubbe”</h2>
<p>Konflikten mellan straffvärdesprincipen och behovsprincipen skapar en nyckfull gråzon av straff och vård samt ökar incitamenten att rekrytera ungdomar till kriminella gäng, då yngre kan begå grova brott i konflikter mellan kriminella gäng eftersom de inte får straffas lika hårt som äldre utan straffrabatt. Därav uttrycket ”att brösta en fyra för att bli en hundragubbe” – en ung kille agerar torped åt gänget och genom att ta på sig eller utföra till exempel mord, som kan ge max fyra års sluten ungdomsvård, blir den unge hundra procent tillförlitlig i den kriminella miljön.</p>
<p>Utvecklingen av den allt grövre brottsligheten som mord och skjutningar på allmän plats visar inte bara att unga kriminella har förlorat respekten för rättssystemet, utan att de också kalkylerar med dess brister.</p>
<p>Socialtjänsten ska bland annat yttra sig innan en ung misstänkt person i åldern 15–17 åtalas. Skälet till det är naturligtvis behovsprincipen. I socialtjänstens yttrande ska man redovisa åtgärder som vidtas och bedöma om den unge har ett särskilt vårdbehov för att motverka en ogynnsam utveckling.<sup>5</sup></p>
<blockquote><p>Ett dilemma med socialtjänstens arbete med grovt kriminella ungdomar är att både tillgodose den unges vårdbehov och hålla den unge kvar i en placering utan att han eller hon rymmer.</p></blockquote>
<p>Yttrandet kan, vid lindrigare brott, påverka åklagaren att avstå från åtal. Om åtal sker kan ett kompetent framställt yttrande ge den unge påföljden ungdomsvård som socialtjänsten har utformat. Tröskeln för att döma till ungdomsvård är att de sociala insatserna anses tillräckligt ingripande utifrån brottslighetens straffvärde (32 kap. 1 § BrB).</p>
<p>Med andra ord krävs att de sociala insatserna anses tillräckligt kännbara för att matcha straffet. I så fall får socialtjänsten helt överta ansvaret för den unge och ge sociala insatser, i annat fall får inte domstolen döma till ungdomsvård. Då återstår ungdomstjänst, ungdomsövervakning eller sluten ungdomsvård. Tröskeln för att döma till sluten ungdomsvård är mycket hög.</p>

<p>Socialtjänstens ansvar för att bedöma ungas behandlingsbehov kräver djupgående kunskap, dels om brottsbenägenheten som påverkar utveckling av brottsligt beteende<sup>6</sup>, dels kunskap om vilka olika behandlingsmetoder som faktiskt är effektiva.</p>
<p>Socionomutbildningen saknar i princip inslag för att kunna göra sådana bedömningar liksom riktade kurser mot till exempel grov ungdomskriminalitet, och inte heller kommunerna verkar ge tillräcklig kunskap.</p>
<p>Det saknas dessutom ett system för implementering av sådan kunskap hos socialtjänsten i landets 290 olika kommuner. Självklart kan enskilda socialsekreterare inse sitt behov av kompetensutveckling och själva skaffa sig sådan kunskap, men forskning visar att socialtjänsten både agerar godtyckligt och mycket olika i fråga om unga som begått brott, vilket medför att unga personer döms mycket olika.<sup>7</sup> Detta är inte bara orättvist utan också skadligt för tilltron till samhället.</p>
<h2>Barnets vårdbehov avgör insatserna</h2>
<p>Socialtjänstens insatser är frivilliga enligt socialtjänstlagen och ska erbjudas utifrån individens behov, till exempel när barn är kriminella. Såväl den unge som föräldrarna kan avböja insatser. Om den unge bedöms ha ett vårdbehov som kräver en specifik insats, kan vård oberoende av samtycke ges med stöd av LVU, lagen med särskilda bestämmelser om vård av unga. LVU är en skyddslag för barn och unga och får inte tillämpas repressivt eller för att skydda samhället från farliga barn. Så samhällsskyddsaspekten får inte finnas här. När ett barn omhändertas ska barnets bästa vara avgörande för all vård som ges. Det är mycket svårt att bedöma vad som är barnets bästa, men ska i princip ge barnet en bättre situation än innan insatsen gavs.<sup>8</sup></p>
<p>Ett dilemma med socialtjänstens arbete med grovt kriminella ungdomar är att både tillgodose den unges vårdbehov och hålla den unge kvar i en placering utan att han eller hon rymmer. Vanligen uppfylls inlåsningen, alltså samhällsskyddsaspekten, men det är betydligt svårare att tillgodose den unges vårdbehov, inte minst på grund av att den unge inte vill ta emot ”hjälpen” att bli inlåst på en låst institution på obestämd tid.</p>
<p>Forskningen visar också att grovt kriminella unga som vårdas inom Statens institutionsstyrelse (SiS) mycket ofta återfaller i brottslighet, särskilt de som har dömts till sluten ungdomsvård.<sup>9</sup></p>
<h2>Sammanblandningen av vård och straff</h2>
<p>Men här finns ytterligare problem som ingen talar om. För det första: De som döms till sluten ungdomsvård hamnar på liknande institutioner (ibland samma) som de unga som har omhändertagits av socialtjänsten enligt LVU.</p>
<p>Två killar, X och Y, är lika kriminella och begår tillsammans ett allvarligt brott. Medan socialtjänsten placerar X inom SiS på obestämd tid enligt LVU för vård, dömer domstolen Y till sluten ungdomsvård ett år. De kan placeras på samma institution.</p>
<p>Efter straffet kan Y bli fortsatt omhändertagen enligt LVU på samma institution. Ytterligare varianter är möjliga.<sup>10</sup></p>
<blockquote><p>LVU-vård bekostas av kommunen med 7 000 kronor/dygn.</p></blockquote>
<p>Unga brottslingar som får den något tvivelaktiga ”förmånen” att dubbelbestraffas på detta sätt, får svårigheter med tilliten till socialtjänsten. Det verkar osannolikt att detta skulle vara för ”barnets bästa”.<sup>11</sup> Så varför är det så? Sannolikt upprätthåller systemet faktiskt möjligheten att hålla unga inlåsta på detta sätt för samhällsskyddets skull. I praktiken tillämpas alltså samhällsskyddet men det kallas för barnets bästa. Detta skadar tvångsvårdens trovärdighet och behandlingens effektivitet.</p>
<p>För det andra: LVU-vård bekostas av kommunen med 7 000 kronor/dygn. Sluten ungdomsvård bekostas av staten. För en liten kommun med svag ekonomi eller med många kriminella, kan kostnaden bli ett incitament att invänta att den unge döms till sluten ungdomsvård, så att det hela betalas av staten i stället för kommunen. Sannolikt skulle ingen socialsekreterare eller kommunal chef tillstå att de medvetet resonerar på det sättet. Men det illustrerar tydligt att systemet sjösattes utan någon analys av dessa paradoxala konsekvenser.</p>
<p>För att ytterligare förstå problemet med nuvarande åtgärder mot ungdomsbrottsligheten behöver vi dela in unga brottslingar i tre kategorier.</p>
<h2>Lågriskungdomar och ambivalenta ungdomar i riskzonen</h2>
<p>En stor andel av alla ungdomar, såväl etniskt svenska som de med invandrarbakgrund, begår brott under uppväxten, vanligen bagatellartade men även allvarligare brott som misshandel eller grov stöld. Sådant sker vanligen i ungdomligt oförstånd, av impulsivitet eller viljan att imponera på kompisar.</p>
<p>Dessa ungdomar har i regel skötsamma kompisar, en prosocial utveckling, fungerande hemförhållanden och skolgång. Här behövs varken straff eller sociala insatser – de ”tillfrisknar” av sig själva. Om sociala insatser ändå behövs finns fungerande metoder för arbete med familj, skola och socialt nätverk. Prognosen i den här gruppen är god<sup>12</sup> och eventuella (mindre ingripande) insatser från socialtjänsten har goda förutsättningar att bli framgångsrika.</p>
<blockquote><p>Många men inte alla unga pojkar som först har dömts till sluten ungdomsvård och sedan omhändertagits genom LVU har invandrarbakgrund&#8230;</p></blockquote>
<p>Unga med riskfaktorer (faktorer som anses öka risken för att begå brott, till exempel svag socioekonomisk situation eller brottsliga kamrater) säger något på gruppnivå om vilka unga som kan tänkas begå brott. Men, det är brottsbenägenheten som är avgörande för <em>vem</em> som väljer att begå brott, vilket vi vanligen inte talar om i Sverige.<sup>13</sup></p>
<p>Unga i riskzonen har fler riskfaktorer än lågriskungdomar och har ofta begått fler och/eller allvarligare brott, men de kan även ha skyddsfaktorer som någorlunda fungerande skolgång och inte alltför svår social problematik. Man kan kalla unga i denna grupp för ambivalenta i så måtto att de inte riktigt bestämt sig för hur de ska välja väg i livet.<sup>14</sup> Socialtjänstens uppgift är att bistå dessa unga med tillgängliga evidensbaserade metoder som inriktas både på ungdomens vilja och mottaglighet och på att stärka familjen med till exempel familjeterapi. Prognosen är god för många i den här gruppen, men en del fortsätter med brott.</p>
<h2>Livsstilskriminella – högriskungdomar</h2>
<p>I gruppen livsstilskriminella är uppväxtvillkoren oftare destruktiva, och de unga börjar tidigt med brott och fortsätter med allvarligare brott.<sup>15</sup> Unga mestadels pojkar som begår så kallade strategiska brott – som rån, grov stöld och våld eller hot mot tjänsteman – löper störst risk för återfall. Närmare 18 procent av de pojkar som begått såna brott lagfördes nio gånger eller fler mellan åren 2010–2014. I socialt utsatta områden är rån ett ännu tydligare strategiskt brott bland pojkar, 22 procent lagfördes nio gånger eller fler för dessa brott.<sup>16</sup></p>
<p>Många men inte alla unga pojkar som först har dömts till sluten ungdomsvård och sedan omhändertagits genom LVU har invandrarbakgrund, majoriteten har svåra problem med adhd, Asperger, autismspektrumstörning, och vissa bedöms intellektuellt ligga i nedre delen av begåvningsskalan. Flertalet uppvisar svåra beteende- och uppförandestörningar, en del lider av allvarlig depression och självmordstankar.<sup>17</sup></p>
<p>Föräldrarna och ungdomarna ligger inte sällan i konflikt med socialtjänsten och vill inte ha med ”soc” att göra alls. Föräldrarna har ofta egna omfattande problem och klarar sällan av att sätta tillräckliga gränser eller kärlek och vägledning. Uppfostringsmetoderna är ofta nyckfulla, och misshandel av barnet är inte ovanligt som uppfostringsmetod vilket även internationell forskning på denna typ av familjer bekräftar.<sup>18</sup></p>
<p>Därför kan grova ungdomsbrottslingars beteende vara ett uttryck för negativ uppfostran och svårigheter i hemmiljön. Detta är naturligtvis djupt försvårande för framgångsrik familjebehandling av de unga brottslingarna och deras familjer, inte minst om familjen inte heller talar och förstår svenska.</p>
<h2>Behandlingsmetoder för unga lagöverträdare</h2>
<p>Så, vad fungerar? Generellt visar resultaten från institutionsbehandling en tämligen dyster utveckling även om viss sådan vård kan fungera, sannolikt då på gruppen unga i riskzonen.<sup>19</sup></p>
<p>Det idag mest lovande alternativet till institutionsplacering av kriminella unga är <em>Treatment foster care oregon</em>, TFCO, som kommer från USA. Metoden innebär att ungdomen placeras i en speciellt rekryterad familj som arbetar heltid med ungdomen med stöd av ett team med terapeuter.<sup>20</sup> Omkring 2 000 ungdomar har bedömts aktuella för metoden, men endast 200 kan komma att behandlas på grund av bristande tillgång. I 70 procent kan behandlingen leda till ett lyckat resultat. För omkring 30 procent uppstår någon form av behandlingssammanbrott.<sup>21</sup> Det innebär att för huvuddelen i högriskgruppen saknas behandling eller så kan behandlingen misslyckas även när den finns tillgänglig för ungdomar med sådana behov.</p>
<p>Andra metoder med hyggliga resultat bygger på terapi, inriktad mot hela familjen och som stöder utvecklingen av föräldrarnas förmågor.<sup>22</sup></p>
<p>Exempel på sådana metoder är <em>multisystemisk terapi</em>, eller <em>funktionell familjeterapi</em>, som liknar TFCO men är avsevärt mindre ingripande. Men samtliga metoder kräver att den som ska behandlas vill och förmår ta emot behandlingen, vilket i sig är problematiskt med de mest kriminella ungdomarna och deras familjer. Dessutom måste behandlingen anpassas individuellt till unga från olika kulturer med olika språk, med vitt skilda problem som till exempel djupgående skolsvårigheter, adhd, Asperger, autismspektrum, intellektuell nedsatthet, djup depression, allvarligt missbruk, våldsamhet och aggressivitet och så vidare.</p>
<p>Problem av detta slag ligger bortom socialsekreterares förmåga att bedöma.</p>
<p>Andra insatser utöver placering av unga är så kallade öppenvårdsinsatser inom socialtjänsten. Studier av Statens beredning för medicinsk och social utvärdering (SBU) visar att det inte går att avgöra vilka specifika öppenvårdsinsatser som är effektiva för ungdomars återfall i brott.<sup>23</sup></p>
<h2>Kunskapsbehov för socialarbetare</h2>
<p>Socionomutbildningen är som sagt otillräcklig. Vidare finns omfattande problem med socialtjänstens brottsinriktade arbete, särskilt för grovt kriminella med neuropsykiatriska svårigheter. Socialtjänsten tillämpar dessutom redan idag samhällsskyddsargument på grova ungdomsbrottslingar.<sup>24</sup></p>
<blockquote><p>Grova ungdomsbrottslingar måste få låsas in utifrån samhällsskyddet under längre tider.</p></blockquote>
<p>Forskning visar överlag låg samstämmighet hos socialtjänstens professionella om hur man ska bedöma ungas problem och behov, liksom bristande kunskap om effektiva ingripandemetoder.<sup>25</sup> Socialtjänstens insatser baseras även på insatsers tillgänglighet snarare än den unges behov<sup>26</sup> och därutöver framgår stora bedömningssvårigheter med det särskilda vårdbehovet.<sup>27</sup> Det är komplicerat i sig att motivera utsatta människor till intensiv familjebehandling. Många familjer med grovt kriminella barn är bristfälligt integrerade i samhället, saknar tillräckliga kunskaper i svenska språket och har låg tillit till socialtjänsten, vilket ytterligare försvårar ett framgångsrikt socialt arbete.</p>
<p>Ofta kritiseras enskilda socialsekreterare för systemets allvarliga brister. Men de utför ett mycket svårt arbete med små resurser och lite stöd, och saknar inte sällan adekvat utbildning.</p>
<h2>Slutord</h2>
<p>Det kommer att ta lång tid innan vi kan vända utvecklingen. Nu krävs en bred och ingående analys för att åtgärda de systembrister som här har uppmärksammats. Flytta ansvaret för grovt kriminella unga från socialtjänsten. Kostnadsansvaret för grovt kriminella ungdomar måste enhetligt överföras till staten, kanske bör det skapas en ny kompetent myndighet med bättre utbildade team med olika professionell kompetens. Lagstiftningen måste ändras för att undvika intressekonflikter och orättvisor.</p>
<p>Grova ungdomsbrottslingar måste få låsas in utifrån samhällsskyddet under längre tider. Öka det förebyggande arbetet för de yngre lagöverträdarna i riskzonen och sätt in insatser redan i förskoleåldern. Socialtjänsten måste få adekvat fortbildning och socionomutbildningen förlängas, förstärkas och specialiseras. För att bryta segregering och nyrekrytering av allt yngre barn till kriminella gäng måste vi, som en förebyggande åtgärd, motverka att fler människor som riskerar utsatthet hamnar i utsatta områden.</p>
<p>Finns det politiska modet och handlingskraften för detta?</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="70130">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li>Tärnfalk, M. (2014). Professionella yttranden. En introduktion till socialt arbete med unga lagöverträdare. Stockholm: Natur &amp; Kultur.</li>
<li>Jareborg, N. &amp; Zila, J. (2000). <em>Straffrättens påföljdslära</em>. Stockholm: Norstedts Juridik.</li>
<li>Regeringens proposition 1997/98:96 Vissa reformer av påföljdssystemet.</li>
<li>Statens offentliga utredningar (1993:35). <em>Reaktion mot ungdomsbrott. </em>Betänkande av Ungdomsbrottskommittén.</li>
<li>Regeringens proposition 2005/06:165 Ingripanden mot unga lagöverträdare.</li>
<li>jmf Wikström P.-O. H. &amp; Treiber, K. (2017). Beyond Risk Factors: An Analytical Approach to Crime Prevention in B. Teasdale and M.S. Bradley (eds.), <em>Preventing Crime and Violence, Advances in Prevention Science,</em> DOI 10.1007/978-3-319-44124-5_8, pp. 73-87.</li>
<li>Ginner Hau, H., &amp; Smedler, A.- C. (2011a). Different problems – same treatment. Swedish juvenile offenders in communitybased rehabilitative programmes. <em>International Journal of Social Welfare</em><em>, </em><em>20</em><em>, 87</em><em>–</em><em>96.; </em>Ginner Hau, H. &amp; Smedler, A.- C. (2011b). Young male offenders in community-based rehabilitative programmes – selfreported history of antisocial behaviour predicts recidivism. <em>International Journal of Social Welfare</em><em>, </em>20(4), 413–420.; Tärnfalk, M. &amp; Alm, C. (2021). Social worker motivations and organisational prerequisites for care of children who commit crimes – the best interests of the child or the protection of society?, European Journal of Social Work, 24:1, 21-33, DOI: <a href="https://www.tandfonline.com/action/showCitFormats?doi=10.1080/13691457.2019.1585334">10.1080/13691457.2019.1585334</a><u>.; </u>Tärnfalk, M. (2007). <em>Barn och brott. En studie om socialtjänstens yttranden i straffprocessen för unga lagöverträdare</em>. Akademisk avhandling. Stockholm: US-AB Print Center.; Åström, T (2016). Att bedöma behov &#8211; utredningar av ungdomar som begått kriminella handlingar. Akademisk avhandling. Stockholm: Karolinska institutet, Eprint AB.</li>
<li>Kaldal, A., &amp; Tärnfalk, M. (2017). Samhällets hantering av barn som begår brott – en verksamhet i flera spår. I Lundström, T. &amp; Leviner, P. (Red.). <em>Tvångsvård av barn och unga </em>–<em> rättigheter, utmaningar och gränszoner </em>(s. 239–261)<em>.</em> Stockholm: Wolters Kluwer. Norstedts juridik.</li>
<li>Pettersson, T. (2010). <em>Återfall i brott bland ungdomar dömda till fängelse respektive sluten ungdomsvård</em>. Statens institutionsstyrelse. Rapport 2/2010.;</li>
<li>Tärnfalk, M. &amp; Kaldal, A. (2012). <em>Barnets bästa när barn begått allvarliga brott. Forskningsansökan till Statens institutionsstyrelse, </em>Dnr 41-205-2012. Opublicerad.</li>
<li>Tärnfalk, M. &amp; Alm, C. (2021). Social worker motivations and organisational prerequisites for care of children who commit crimes – the best interests of the child or the protection of society?, <em>European Journal of Social Work</em>, 24:1, 21-33, DOI: <a href="https://www.tandfonline.com/action/showCitFormats?doi=10.1080/13691457.2019.1585334">10.1080/13691457.2019.1585334</a><u>.;</u></li>
</ol>
<p>&nbsp;</p>
<ol start="12">
<li>Socialstyrelsen (2020). Handbok för socialtjänsten.</li>
</ol>
<p>&nbsp;</p>
<ol start="13">
<li>Wikström P.-O. H. &amp; Treiber, K. (2017). Beyond Risk Factors: An Analytical Approach to Crime Prevention. In B. Teasdale and M.S. Bradley (eds.), <em>Preventing Crime and Violence, Advances in Prevention Science,</em> DOI 10.1007/978-3-319-44124-5_8, pp. 73-87.</li>
<li>Laub, J., H. &amp; Sampson, R., J. (2003). Shared beginnings, divergent lives. Delinquent boys to age 70. Harvard: Harvard University Press.; Wikström P.-O. H. &amp; Treiber, K. (2017). Beyond Risk Factors: An Analytical Approach to Crime Prevention in B. Teasdale and M.S. Bradley (eds.), <em>Preventing Crime and Violence, Advances in Prevention Science,</em> DOI 10.1007/978-3-319-44124-5_8, pp. 73-87.</li>
<li>Torstensson, M. (2013). <em>Kronisk kriminalitet som livsstil</em>. Rikspolisens utvärderingsfunktion. Rapport 2013:2. Rikspolisstyrelsen.</li>
<li>Brottsförebyggande rådet (2021). <em>Ungdomsrån. En kartläggning av nuläge och utveckling</em>. Rapport 2021:19.</li>
<li>Tärnfalk, M. &amp; Alm, C. (2021). Social worker motivations and organisational prerequisites for care of children who commit crimes – the best interests of the child or the protection of society?, European Journal of Social Work, 24:1, 21-33.; Bartol, C. A. &amp; Bartol, A. M. (2005). <em>Criminal behavior. A Psychosocial Approach</em>. Seventh edition. New Jersey: Pearson international.</li>
<li>Vinnerljung, B. &amp; Andreassen, T. (2015). Barn och unga i samhällets vård. Forskning om den sociala dygnsvården. <em>Forskning i korthet #4. Forskningsrådet för hälsa, arbetsliv och välfärd</em>.; Andreassen, T. (2003).<em> Institutionsbehandling av ungdomar – vad säger forskningen? </em>Stockholm: Gothia.</li>
<li>https://www.socialstyrelsen.se/kunskapsstod-och-regler/omraden/evidensbaserad-praktik/metodguiden/tfco-treatment-foster-care-oregon/</li>
<li>Martin Bergström, docent i socialt arbete, Lunds universitet, i Sveriges Radio, Vetenskapsradion P1, 12 november 2021. https://sverigesradio.se/avsnitt/sa-kan-stokiga-tonaringar-fa-hjalp-bort-fran-kriminalitet</li>
<li>Andershed, H. &amp; Andershed, A.K. &amp; Söderholm Carpelan, K. (2010). <em>Ungdomar som begår brott –Vilka insatser fungerar? </em>Stockholm: Gothia.</li>
<li>Statens Beredning för medicinsk Utvärdering (2020). <em>Insatser i öppenvård för att förebygga ungdomars återfall i brott</em>. Systematisk kunskapsöversikt, artikel 308.</li>
<li>Tärnfalk, M., Kaldal, A., &amp; Alm, C. (2022). <em>Barnets bästa när barn begått allvarliga brott</em>. Institutionsvård i fokus. Nr 1, 2022. Statens institutionsstyrelse.</li>
<li>Andershed, A.-K., &amp; Andershed, H. (2016). Improving evidence-based social work practice with youths exhibiting conduct problems through structured assessment. <em>European Journal of Social Work</em><em>,</em> 19(6), 887–900.; Andrée Löfholm, C., Brännström, L., Olsson, M., &amp; &amp; Hansson, K. (2013). Treatment-as-usual in effectiveness studies: What is it and does it matter? <em>International Journal of Social Welfare</em>, 22, 25–34.; Ginner Hau, H., &amp; Smedler, A.- C. (2011a). Different problems – same treatment. Swedish juvenile offenders in communitybased rehabilitative programmes. <em>International Journal of Social Welfare</em><em>, </em><em>20</em><em>, 87</em><em>–</em><em>96.</em>; Ginner Hau, H. &amp; Smedler, A.- C. (2011b). Young male offenders in community-based rehabilitative programmes – selfreported history of antisocial behaviour predicts recidivism. <em>International Journal of Social Welfare</em><em>, </em>20(4), 413–420.;</li>
</ol>
<p>Kaunitz, C. (2017). Aggression Replacement Training (ART) i Sverige – spridning, programtrohet, målgrupp och utvärdering. Licentiat avhandling. Stockholm: Eprint AB Stockholms universitet.</p>
<p>Åström, T., Jergeby, U., Andershed, A.-K., &amp; Tengström, A. (2013). Social workers’ assessments of needs and interventions for adolescents with substance misuse problems, criminal behavior and mental health difficulties: A vignette study. <em>European Journal of Social Work</em>, 16(5), 635–650.;</p>
<ol start="26">
<li>Ginner Hau, H., &amp; Smedler, A.- C. (2011a). Different problems – same treatment. Swedish juvenile offenders in communitybased rehabilitative programmes. <em>International Journal of Social Welfare</em><em>, </em><em>20</em><em>, 87</em><em>–</em><em>96.; </em>Ginner Hau, H. &amp; Smedler, A.-C. (2011b). Young male offenders in community-based rehabilitative programmes – selfreported history of antisocial behaviour predicts recidivism. <em>International Journal of Social Welfare</em><em>, </em>20(4), 413–420.; Tärnfalk, M. &amp; Alm, C. (2021). Social worker motivations and organisational prerequisites for care of children who commit crimes – the best interests of the child or the protection of society?, <em>European Journal of Social Work</em>, 24:1, 21-33.</li>
<li>Brottsförebyggande rådet (2011). <em>Ungdomsvård och ungdomstjänst. En utvärdering av 2007 års påföljdsreform för unga lagöverträdare</em>. Rapport 2011:10.</li>
</ol>
</div>
</div>
<div class="author-byline">Michael Tärnfalk är forskare i socialt arbete och tidigare verksam som socialsekreterare för unga lagöverträdare inom socialtjänsten och på Fryshusets högstadieskola. Han har därutöver verkat som familjehem samt som övervakare och kontaktperson.
</div>
</div>
