diff --git a/pgpainless-core/src/main/java/org/pgpainless/key/generation/KeySpecBuilder.java b/pgpainless-core/src/main/java/org/pgpainless/key/generation/KeySpecBuilder.java
deleted file mode 100644
index 559dd3ce..00000000
--- a/pgpainless-core/src/main/java/org/pgpainless/key/generation/KeySpecBuilder.java
+++ /dev/null
@@ -1,92 +0,0 @@
-// SPDX-FileCopyrightText: 2018 Paul Schaub <vanitasvitae@fsfe.org>
-//
-// SPDX-License-Identifier: Apache-2.0
-
-package org.pgpainless.key.generation;
-
-import java.util.Arrays;
-import java.util.Date;
-import java.util.LinkedHashSet;
-import java.util.Set;
-import javax.annotation.Nonnull;
-
-import org.pgpainless.PGPainless;
-import org.pgpainless.algorithm.AlgorithmSuite;
-import org.pgpainless.algorithm.CompressionAlgorithm;
-import org.pgpainless.algorithm.Feature;
-import org.pgpainless.algorithm.HashAlgorithm;
-import org.pgpainless.algorithm.KeyFlag;
-import org.pgpainless.algorithm.SymmetricKeyAlgorithm;
-import org.pgpainless.key.generation.type.KeyType;
-import org.pgpainless.signature.subpackets.SelfSignatureSubpackets;
-import org.pgpainless.signature.subpackets.SignatureSubpackets;
-import org.pgpainless.signature.subpackets.SignatureSubpacketsUtil;
-import org.pgpainless.util.CollectionUtils;
-
-public class KeySpecBuilder implements KeySpecBuilderInterface {
-
-    private final KeyType type;
-    private final KeyFlag[] keyFlags;
-    private final SelfSignatureSubpackets hashedSubpackets = new SignatureSubpackets();
-    private final AlgorithmSuite algorithmSuite = PGPainless.getPolicy().getKeyGenerationAlgorithmSuite();
-    private Set<CompressionAlgorithm> preferredCompressionAlgorithms = algorithmSuite.getCompressionAlgorithms();
-    private Set<HashAlgorithm> preferredHashAlgorithms = algorithmSuite.getHashAlgorithms();
-    private Set<SymmetricKeyAlgorithm> preferredSymmetricAlgorithms = algorithmSuite.getSymmetricKeyAlgorithms();
-    private Date keyCreationDate;
-
-    KeySpecBuilder(@Nonnull KeyType type, KeyFlag flag, KeyFlag... flags) {
-        if (flag == null) {
-            throw new IllegalArgumentException("Key MUST carry at least one key flag");
-        }
-        if (flags == null) {
-            throw new IllegalArgumentException("List of additional flags MUST NOT be null.");
-        }
-        flags = CollectionUtils.concat(flag, flags);
-        SignatureSubpacketsUtil.assureKeyCanCarryFlags(type, flags);
-        this.type = type;
-        this.keyFlags = flags;
-    }
-
-    @Override
-    public KeySpecBuilder overridePreferredCompressionAlgorithms(
-            @Nonnull CompressionAlgorithm... compressionAlgorithms) {
-        this.preferredCompressionAlgorithms = new LinkedHashSet<>(Arrays.asList(compressionAlgorithms));
-        return this;
-    }
-
-    @Override
-    public KeySpecBuilder overridePreferredHashAlgorithms(
-            @Nonnull HashAlgorithm... preferredHashAlgorithms) {
-        this.preferredHashAlgorithms = new LinkedHashSet<>(Arrays.asList(preferredHashAlgorithms));
-        return this;
-    }
-
-    @Override
-    public KeySpecBuilder overridePreferredSymmetricKeyAlgorithms(
-            @Nonnull SymmetricKeyAlgorithm... preferredSymmetricKeyAlgorithms) {
-        for (SymmetricKeyAlgorithm algo : preferredSymmetricKeyAlgorithms) {
-            if (algo == SymmetricKeyAlgorithm.NULL) {
-                throw new IllegalArgumentException("NULL (unencrypted) is an invalid symmetric key algorithm preference.");
-            }
-        }
-        this.preferredSymmetricAlgorithms = new LinkedHashSet<>(Arrays.asList(preferredSymmetricKeyAlgorithms));
-        return this;
-    }
-
-    @Override
-    public KeySpecBuilder setKeyCreationDate(@Nonnull Date creationDate) {
-        this.keyCreationDate = creationDate;
-        return this;
-    }
-
-    @Override
-    public KeySpec build() {
-        this.hashedSubpackets.setKeyFlags(keyFlags);
-        this.hashedSubpackets.setPreferredCompressionAlgorithms(preferredCompressionAlgorithms);
-        this.hashedSubpackets.setPreferredHashAlgorithms(preferredHashAlgorithms);
-        this.hashedSubpackets.setPreferredSymmetricKeyAlgorithms(preferredSymmetricAlgorithms);
-        this.hashedSubpackets.setFeatures(Feature.MODIFICATION_DETECTION);
-
-        return new KeySpec(type, (SignatureSubpackets) hashedSubpackets, false, keyCreationDate);
-    }
-}
diff --git a/pgpainless-core/src/main/kotlin/org/pgpainless/key/generation/KeySpecBuilder.kt b/pgpainless-core/src/main/kotlin/org/pgpainless/key/generation/KeySpecBuilder.kt
new file mode 100644
index 00000000..71d876ea
--- /dev/null
+++ b/pgpainless-core/src/main/kotlin/org/pgpainless/key/generation/KeySpecBuilder.kt
@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+package org.pgpainless.key.generation
+
+import org.pgpainless.PGPainless
+import org.pgpainless.algorithm.*
+import org.pgpainless.key.generation.type.KeyType
+import org.pgpainless.signature.subpackets.SelfSignatureSubpackets
+import org.pgpainless.signature.subpackets.SignatureSubpackets
+import org.pgpainless.signature.subpackets.SignatureSubpacketsUtil
+import java.util.*
+
+class KeySpecBuilder private constructor(
+        private val type: KeyType,
+        private val keyFlags: List<KeyFlag>,
+) : KeySpecBuilderInterface {
+
+    private val hashedSubpackets: SelfSignatureSubpackets = SignatureSubpackets()
+    private val algorithmSuite: AlgorithmSuite = PGPainless.getPolicy().keyGenerationAlgorithmSuite
+    private var preferredCompressionAlgorithms: Set<CompressionAlgorithm> = algorithmSuite.compressionAlgorithms
+    private var preferredHashAlgorithms: Set<HashAlgorithm> = algorithmSuite.hashAlgorithms
+    private var preferredSymmetricAlgorithms: Set<SymmetricKeyAlgorithm> = algorithmSuite.symmetricKeyAlgorithms
+    private var keyCreationDate = Date()
+
+    constructor(
+            type: KeyType,
+            keyFlag: KeyFlag,
+            vararg keyFlags: KeyFlag
+    ) : this(type, listOf(keyFlag).plus(keyFlags))
+
+    init {
+        SignatureSubpacketsUtil.assureKeyCanCarryFlags(type, *keyFlags.toTypedArray())
+    }
+
+    override fun overridePreferredCompressionAlgorithms(vararg algorithms: CompressionAlgorithm): KeySpecBuilder = apply {
+        this.preferredCompressionAlgorithms = algorithms.toSet()
+    }
+
+    override fun overridePreferredHashAlgorithms(vararg algorithms: HashAlgorithm): KeySpecBuilder = apply {
+        this.preferredHashAlgorithms = algorithms.toSet()
+    }
+
+    override fun overridePreferredSymmetricKeyAlgorithms(vararg algorithms: SymmetricKeyAlgorithm): KeySpecBuilder = apply {
+        require(!algorithms.contains(SymmetricKeyAlgorithm.NULL)) {
+            "NULL (unencrypted) is an invalid symmetric key algorithm preference."
+        }
+        this.preferredSymmetricAlgorithms = algorithms.toSet()
+    }
+
+    override fun setKeyCreationDate(creationDate: Date): KeySpecBuilder = apply {
+        this.keyCreationDate = creationDate
+    }
+
+    override fun build(): KeySpec {
+        return hashedSubpackets.apply {
+            setKeyFlags(keyFlags)
+            setPreferredCompressionAlgorithms(preferredCompressionAlgorithms)
+            setPreferredHashAlgorithms(preferredHashAlgorithms)
+            setPreferredSymmetricKeyAlgorithms(preferredSymmetricAlgorithms)
+            setFeatures(Feature.MODIFICATION_DETECTION)
+        }.let {
+            KeySpec(type, hashedSubpackets as SignatureSubpackets, false, keyCreationDate)
+        }
+    }
+}
\ No newline at end of file