Fiber Arts | blog.kittenin.space

A Scrappy Slip Stitch Hat Pattern

Mon, 12 Oct 2026 17:15:22 -0400

I can’t remember the last time I followed a pattern exactly. Often patterns are just suggestions or guides for me, not must-follow instructions; a gauge swatch is a test of fabric drape and density used to calculate the real numbers I’ll need against a pattern’s own gauge; sweater lengths and pattern repeats and charts are ideas to be taken, adapted, and occasionally discarded.

And yet I have never come up with my own pattern, 100% completely from scratch in over 20 years of knitting and crocheting.

That is, until now.

The Scrappy Slip Stitch Hat was born out of my desire to use the last of my Berroco Vintage Chunky to make some hats with a simple pattern that only required the use of one color at a time. It requires only a small amount of yarn and a consistent main color; although, really, you don’t even need that – it is, after all, scrappy; switch yarn colors every two rows if that’s what you see fit. It also incorporates the pattern into the crown shaping, which was easy now that I think of it, but I still feel oddly proud of.

So if you, too, have some bulky scrap yarn and a desire for a hat, here are my instructions: Follow them as much or as little as you need.

My hats came to about 9" width when laid flat, unstretched. They comfortably fit my 21.5" head and I’ve got about 3-4" of give left in there. I’d estimate they could comfortably fit heads 20-25 inches in size.

Gauge

18 stitches per 4 inches x 24 rows per 4 inches (it’s the slip stitches!)

Supplies

Bulky Yarn

I used 73 grams/100 yards purple and 62 grams/44 yards black for my purple and black hat with the folded brim.

I used 50 grams/68 yards mushroom (that undyed cream color), and 19 grams/24 yards of each of the oranges for the mushroom and orange hat with the regular brim.

Knitting Needles

10 US / 6.0 mm 16" circulars or DPNs for the brim
10.5 US / 6.5 mm 16" circulars or DPNs for the head; if using circulars you will need to switch to DPNs, use magic loop with a longer cable, or add a second set of 10.5 circulars for the crown

The Pattern

Ribbing

Size 10 needles

Cast on 86 stitches with the main color (MC)
Knit ribbing (k1, p1) for desired length, keeping track of how many rows you have knit if you want a folded brim. If not knitting a folded brim, stop at your desired length. (I knit 10 rows for my purple hat; 7 for the mushroom.)
Folded brim only: Purl 1 row
Folded brim only: Knit ribbing (k1, p1) again for the same amount of rows as prior to the purl row (i.e., I knit 10 rows for my purple hat with the folded brim)
Folded brim only: Knit one more row of ribbing, when at a knit stitch, pick up the cast on edge of the stitch at the bottom of the row (it will look like a purl from the back); knit the two stitches together.

Head

Switch to size 10.5 needles (if you want, I forgot for the mushroom hat)

Starting with the contrast color, repeat the following until you want to begin crown decreases:

Row 1 (CC): (Slip1 k1) to end

Row 2 (CC): Knit

Row 3 (MC): (k1 slip 1)to end

Row 4: (MC): Knit

End after a row 1 repeat.

Crown

Row 1 (CC): K7 k3tog (k11 k3tog) 5 times k6 (74 stitches)

Row 2 (MC): Knit in pattern

Row 3 (MC): K6 k3tog (k9 k3tog) 5 times k5 (62)

Row 4 (CC): Knit in pattern

Row 5 (CC): K5 k3tog (k7 k3tog) 5 times k4 (50)

Row 6 (MC): Knit in pattern

Row 7(MC): K4 k3tog (k5 k3tog) 5 times k3 (38)

Row 8 (CC): Knit in pattern

Row 9 (CC): (k3 k3tog) 6 times k2 (26)

Row 10 (MC): Knit in pattern

Row 11 (MC): K2 k3tog (k1 k3tog) 5 times k1 (14)

Row 12 (CC): Knit in pattern

Row 13 (CC): (k2togbl k2tog) to end (7)

Cut both threads and pull through loops; weave in ends.

And that’s it! Eventually I plan on grading this to have a larger and smaller version, upon which I’ll maybe run a small test (just to test running a pattern test), and release it as a PDF pattern on Ravelry. But until then: Enjoy! And be sure to ping me on Ravelry if you use the pattern!

Projects in this post:

My Yarn Can't Reach the Moon, But It Can Make It Up Everest 23 Times

Wed, 23 Sep 2026 17:30:13 -0400

I have been knitting for over 20 years.

I learned from the Internet, slightly after YouTube was created but before it really took off, from the low-res videos on a particularly periwinkle knitting help website. I also read blogs: so many blogs. The Internet was awash in knitting blogs back then, and they were some of the most widely-read blogs out there. Seriously. It was A Whole Thing.

One of the habits I picked up from these blogs was Always Buy An Extra Skein of Yarn. This prevented the woe one would experience when they came up short for a project and couldn’t get to the store; or worse yet, could, but found the store was sold out or only had yarn from a visibly different dye lot. (This was, as you could imagine, before most yarn stores were selling online.) And when you are just starting out, with 6 balls of yarn to your name, this is an amazing idea.

Eventually, however, this became An Issue.

This became an issue because often I would not use those extra skeins, leaving me with too little yarn to really make anything other than hats, which I did not really wear (and it would be several years before I met my husband, who does wear knit hats). This became an issue, because like most new knitters, I found the projects I were drawn to were not the projects I wore. This became an issue, because I am a dedicated frogger of those unworn projects, meaning while I also bought yarn for new projects, plenty of my old projects stopped being projects and became balls of yarn again. Oops. I also inherited my mother-in-law’s yarn stash, which certainly embiggened my own.

That said, it’s also easy enough to not realize how much yarn you have. This might seem preposterous given that I have literally hundreds of balls of yarn, but until I moved into my current house, most of my yarn lived in boxes and bags that were around and I did not know what I had, so I would find a new project and look through some of the stash, but forget the other bits of it existed, and then just buy new yarn if I didn’t have enough of what I wanted or the yarn I could see just wasn’t right. Also, balls of yarn are small, especially if you compress them into plastic ziplock bags to keep the moths out.

But then I moved. I put all my yarn into one place. I also I stashed it on Ravelry. And that was when I realized I might have a not-so-small problem.

And so, last January, I stopped buying yarn. The more whimsical of you might say I began my stashbusting journey, but mostly I would argue that I finally just new what I had and it became easier to use it.

Since then, I have used almost 100 individual skeins of yarn. Most of it was bulky-weight or thicker, meaning I cleared out over three bags in what felt like record time. I also got to use yarn I had mostly fallen out of love with because I bought it when I was eighteen and tried projects I would have never made before. Seriously, who knew fluffy amigurumi yarn critters would be so cute? Mushroom Guys? Fuzzy cat hats? Giant cotton cardigans I wear constantly even though it’s pink and striped? Sign me up. Not forever – I’ve crawled back to fingering- and lace-weight shawls lately for the technical challenge after months of bulky fluff. But after 20 years, it’s been interesting to discover there is still plenty of things to try – or try again after a decade or so.

That said, if I maintain my current trajectory, I still have about 9 years before I run out of yarn. Wish me luck?

Patterns and projects shown/referenced in this post:

Lessons Learned by Counting Rows From Sheep

Mon, 21 Sep 2026 17:52:36 -0400

Whenever learning a new programming language, framework, backend, or tech skill, I have always relied on remaking the same applications: This lets me focus on learning, not product design. Initially, this was a simple to-do list application I called “Forethought,” although I also dabbled in pomodoro timers. But after a time, I wanted to try to make something important to me: And as a knitter and crocheter perpetually unhappy with my row counting applications, I realized what I wanted out of a row counter was what I wanted out of, well, fiber arts in the first place – a app customized to me.

Gauge Swatch: The First Version

When I first built Count Rows From Sheep – a name that has persevered through every version – it was with Node.js and Express, using MongoDB as a database to store row counter and project information. Truth be told, I did not get too far with it: I got the Express server set up, the database schema, an intended item structure, and part of a REST API coded.

But then I saw a new shiny: I had started experimenting with TypeScript and React, and decided to pivot. You might say the gauge swatch worked: It let me realize what I wanted out of the fabric of the application. It was just a little different than what I started with.

Frogging: Realizing What I Really Wanted (But Only After Making an Entire App)

I started from scratch with version 2. Like the unfinished first iteration, this version of Count Rows From Sheep used something JavaScript-esque, with TypeScript, and created an Express RESTful API. I switched the database to Postgres with Prisma, allowing me to logically organize my database tables with schemas and handle project and row counter data without spending too much time on database management.

I also finally got to the front end, and I admit: I spent most of my time here. There’s something to be said about having written the API partially before. TypeScript and Express weren’t new to me, and Postgres/Prisma removed some of the weight of database schemas. This let me focus learning more React, building Count Rows From Sheep as a single-page application.

This also let me realize the things I really wanted from both the UI and the application as a whole: Clean, easy-to-use counters that can be visually linked and configured to track repeats, and an affective pattern viewer that let me highlight charts, write annotations, and add text. I also wanted to be able to change themes and settings based on my mood – I’m a native of the 90s and 00s Internet; I love some color.

Finally, with everything working how I (think) I wanted, I added authentication: This was a progressive web app, after all! If someone other than me wanted to use it, they would need their own account. This was the first time I had ever implemented auth to an app, and I leveraged bcrypt and JSON Web Tokens. I also set up invite codes, since I didn’t exactly want to release the app to other users yet.

And that’s a good thing: Because when I started using it, I realized I kind of hated it.

When I decided to build a progressive web app, it was primarily because I was impressed by the PWA of others: Dabble Writer, in particular, is an application I thought was really cool. I wanted to do that! And so I did: But then while using it, I realized that a.) needing the Internet to use my row counter kind of sucked, and b.) I didn’t actually care about using the app on multiple devices. I also didn’t like the $40+/month bill I was paying Digital Ocean just to use it myself.

The FO: Count Rows From Sheep

After a few months of using my PWA web app exclusively, I decided to start fresh again. I wanted to rip out the database in favor of storing project data as JSON files, have it work local-first (and local-only), and provide users the option to use it on their platform of choice (so long as it was a platform I already used and could test it on). This led me to Tauri, which meant I was rewriting the backend again: This time in Rust! I had never actually used Rust before, but the transition to JSON-based project files made this a lot less intimidating than it would have been: It was all CRUD functions! No databases to integrate with! And best of all: It was quick as hell to use. (Well, except for the brief foray into using Android SAF so the user could see their project files in the tablet filesystem, but apparently that was a bad idea.)

With the backend simplified, this let me dive head-first into the frontend again: I kept up with using React, although since I knew I wanted more and more (and more and more) themes, I decided to try out Tailwind CSS. And while I won’t say Tailwind is the only reason I was able to implement custom, user-supplied themes, it didn’t hurt, either.

Since this was the second time leveraging React for the frontend, I was also able to go in with a better idea of what I wanted and how to get there. For example, one simple quality-of-life feature I was adamant about was the ability to move my row counters to the bottom of the screen, where I can see them best on my tab

I also didn’t want to lose portability entirely: But instead of native syncing between devices, which would involve a server and cost money, I developed a simple export/import system. You can save a project – or all your projects – exported as a zip, then import that zip onto a different decide with Count Rows From Sheep on it; it doesn’t even have to be the same type of device! I work from Windows to Android and occasionally Linux as needed. And it means the application can always be free!

I have never finished an application before – at least not one I wanted to share. But Count Rows From Sheep became something more than a learning experience for me: It became a customized application suited to my knitting and crochet needs, like how my knitting and crochet projects are clothes and accessories made just for me and my loved ones. Of course, that doesn’t mean I don’t want to share, and you can currently download Count Rows From Sheep from the CRFS website for Windows and Linux. Android is still in closed testing, but drop me an email if you want an invite; bonus points if you can take 30 minutes to run through a test survey!